Remove QLinkedList

QLinkedList has been moved to Qt5Compat. Remove and stop mentioning
it in docs, examples (the docs & examples for QLinkedList itself will
be moved to Qt5Compat) and remove the corresponding tests.

Also remove QT_NO_LINKED_LIST, since it's not needed anymore.

Task-number: QTBUG-81630
Task-number: QTBUG-80312
Change-Id: I4a8f1105cb60aa87e7fd67e901ec1a27c489aa31
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

2 files changed, 0 insertions, 655 deletions

diff --git a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro b/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro
index b372923310..f2e3e0c8e1 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro
+++ b/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro
@@ -2,4 +2,3 @@ CONFIG += testcase
 TARGET = tst_qtconcurrentfilter
 QT = core testlib concurrent
 SOURCES = tst_qtconcurrentfilter.cpp
-DEFINES -= QT_NO_LINKED_LIST
diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
index 8c4e1c16f3..e6ac829230 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
+++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
@@ -28,7 +28,6 @@
 #include <qtconcurrentfilter.h>
 #include <QCoreApplication>
 #include <QList>
-#include <QLinkedList>
 #include <QtTest/QtTest>
 
 #include "../qtconcurrentmap/functions.h"
@@ -63,18 +62,6 @@ void tst_QtConcurrentFilter::filter()
         QCOMPARE(list, QList<int>() << 2 << 4);
     }
     {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::filter(linkedList, KeepEvenIntegers()).waitForFinished();
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::blockingFilter(linkedList, KeepEvenIntegers());
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
-    {
         QVector<int> vector;
         vector << 1 << 2 << 3 << 4;
         QtConcurrent::filter(vector, KeepEvenIntegers()).waitForFinished();
@@ -100,18 +87,6 @@ void tst_QtConcurrentFilter::filter()
         QtConcurrent::blockingFilter(list, keepEvenIntegers);
         QCOMPARE(list, QList<int>() << 2 << 4);
     }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished();
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::blockingFilter(linkedList, keepEvenIntegers);
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
 
     // bound function
     {
@@ -126,18 +101,6 @@ void tst_QtConcurrentFilter::filter()
         QtConcurrent::blockingFilter(list, keepEvenIntegers);
         QCOMPARE(list, QList<int>() << 2 << 4);
     }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished();
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::blockingFilter(linkedList, keepEvenIntegers);
-        QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4);
-    }
 
     // member
     {
@@ -152,18 +115,6 @@ void tst_QtConcurrentFilter::filter()
         QtConcurrent::blockingFilter(list, &Number::isEven);
         QCOMPARE(list, QList<Number>() << 2 << 4);
     }
-    {
-        QLinkedList<Number> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::filter(linkedList, &Number::isEven).waitForFinished();
-        QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QtConcurrent::blockingFilter(linkedList, &Number::isEven);
-        QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4);
-    }
 }
 
 void tst_QtConcurrentFilter::filtered()
@@ -219,19 +170,6 @@ void tst_QtConcurrentFilter::filtered()
         QCOMPARE(f.results(), QList<int>() << 2 << 4);
     }
 
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, KeepEvenIntegers());
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList;
-        linkedList << 1 << 2 << 3 << 4;
-        QFuture<int> f = QtConcurrent::filtered(linkedList, KeepEvenIntegers());
-        QCOMPARE(f.results(), QList<int>() << 2 << 4);
-    }
-
     // function
     {
         QFuture<int> f = QtConcurrent::filtered(list, keepEvenIntegers);
@@ -351,172 +289,6 @@ void tst_QtConcurrentFilter::filtered()
                                                            &Number::isEven);
         QCOMPARE(list2, QList<Number>() << 2 << 4);
     }
-
-    // same thing on linked lists
-
-    QLinkedList<int> linkedList;
-    linkedList << 1 << 2 << 3 << 4;
-
-    // functor
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList, KeepEvenIntegers());
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
-                                                linkedList.end(),
-                                                KeepEvenIntegers());
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
-                                                linkedList.constEnd(),
-                                                KeepEvenIntegers());
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, KeepEvenIntegers());
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
-                                                                                         linkedList.end(),
-                                                                                         KeepEvenIntegers());
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
-                                                                                         linkedList.constEnd(),
-                                                                                         KeepEvenIntegers());
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-
-    // function
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
-                                                linkedList.end(),
-                                                keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
-                                                linkedList.constEnd(),
-                                                keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
-                                                                                         linkedList.end(),
-                                                                                         keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
-                                                                                         linkedList.constEnd(),
-                                                                                         keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-
-    // bound function
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.begin(),
-                                                linkedList.end(),
-                                                keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(),
-                                                linkedList.constEnd(),
-                                                keepEvenIntegers);
-        QList<int> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(),
-                                                                                         linkedList.end(),
-                                                                                         keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(),
-                                                                                         linkedList.constEnd(),
-                                                                                         keepEvenIntegers);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-
-    // const member function
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QFuture<Number> f = QtConcurrent::filtered(integers, &Number::isEven);
-        QList<Number> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QFuture<Number> f = QtConcurrent::filtered(integers.begin(),
-                                                   integers.end(),
-                                                   &Number::isEven);
-        QList<Number> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QFuture<Number> f = QtConcurrent::filtered(integers.constBegin(),
-                                                   integers.constEnd(),
-                                                   &Number::isEven);
-        QList<Number> linkedList2 = f.results();
-        QCOMPARE(linkedList2, QList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered(integers, &Number::isEven);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.begin(),
-                                                                                               integers.end(),
-                                                                                               &Number::isEven);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> integers;
-        integers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 =
-            QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.constBegin(),
-                                                                 integers.constEnd(),
-                                                                 &Number::isEven);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
 }
 
 void tst_QtConcurrentFilter::filteredReduced()
@@ -956,432 +728,6 @@ void tst_QtConcurrentFilter::filteredReduced()
         QCOMPARE(sum, 6);
     }
 
-    // same as above on linked lists
-    QLinkedList<int> linkedList;
-    linkedList << 1 << 2 << 3 << 4;
-    QLinkedList<Number> numberLinkedList;
-    numberLinkedList << 1 << 2 << 3 << 4;
-
-    // functor-functor
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(),
-                                                     linkedList.end(),
-                                                     KeepEvenIntegers(),
-                                                     IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::filteredReduced<int>(linkedList.begin(),
-                                                      linkedList.end(),
-                                                      keepEvenIntegers,
-                                                      intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
-                                                     linkedList.constEnd(),
-                                                     KeepEvenIntegers(),
-                                                     IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
-                                                      linkedList.constEnd(),
-                                                      keepEvenIntegers,
-                                                      intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
-                                                             linkedList.end(),
-                                                             KeepEvenIntegers(),
-                                                             IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
-                                                              linkedList.end(),
-                                                              keepEvenIntegers,
-                                                              intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
-                                                             linkedList.constEnd(),
-                                                             KeepEvenIntegers(),
-                                                             IntSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
-                                                              linkedList.constEnd(),
-                                                              keepEvenIntegers,
-                                                              intSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-
-    // function-functor
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(),
-                                                     linkedList.end(),
-                                                     keepEvenIntegers,
-                                                     IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(),
-                                                     linkedList.constEnd(),
-                                                     keepEvenIntegers,
-                                                     IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(),
-                                                             linkedList.end(),
-                                                             keepEvenIntegers,
-                                                             IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(),
-                                                             linkedList.constEnd(),
-                                                             keepEvenIntegers,
-                                                             IntSumReduce());
-        QCOMPARE(sum, 6);
-    }
-
-    // functor-function
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList, KeepEvenIntegers(), intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList.begin(),
-                                                linkedList.end(),
-                                                KeepEvenIntegers(),
-                                                intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList.constBegin(),
-                                                linkedList.constEnd(),
-                                                KeepEvenIntegers(),
-                                                intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList, KeepEvenIntegers(), intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
-                                                        linkedList.end(),
-                                                        KeepEvenIntegers(),
-                                                        intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
-                                                        linkedList.constEnd(),
-                                                        KeepEvenIntegers(),
-                                                        intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-
-    // function-function
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList, keepEvenIntegers, intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList.begin(),
-                                                linkedList.end(),
-                                                keepEvenIntegers,
-                                                intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(linkedList.constBegin(),
-                                                linkedList.constEnd(),
-                                                keepEvenIntegers,
-                                                intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList, keepEvenIntegers, intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
-                                                        linkedList.end(),
-                                                        keepEvenIntegers,
-                                                        intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
-                                                        linkedList.constEnd(),
-                                                        keepEvenIntegers,
-                                                        intSumReduce);
-        QCOMPARE(sum, 6);
-    }
-
-    // functor-member
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList, KeepEvenIntegers(), &QLinkedList<int>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.begin(),
-                                                                     linkedList.end(),
-                                                                     KeepEvenIntegers(),
-                                                                     &QLinkedList<int>::append,
-                                                                     QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.constBegin(),
-                                                                     linkedList.constEnd(),
-                                                                     KeepEvenIntegers(),
-                                                                     &QLinkedList<int>::append,
-                                                                     QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList, KeepEvenIntegers(), &QLinkedList<int>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
-                                                                             linkedList.end(),
-                                                                             KeepEvenIntegers(),
-                                                                             &QLinkedList<int>::append,
-                                                                             QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
-                                                                             linkedList.constEnd(),
-                                                                             KeepEvenIntegers(),
-                                                                             &QLinkedList<int>::append,
-                                                                             QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-
-    // member-functor
-    {
-        int sum = QtConcurrent::filteredReduced<int>(numberLinkedList, &Number::isEven, NumberSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::filteredReduced<int>(QLinkedList<Number>(numberLinkedList),
-                                                      &Number::isEven,
-                                                      NumberSumReduce());
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(numberLinkedList.begin(),
-                                                     numberLinkedList.end(),
-                                                     &Number::isEven,
-                                                     NumberSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced<int>(numberLinkedList.constBegin(),
-                                                     numberLinkedList.constEnd(),
-                                                     &Number::isEven,
-                                                     NumberSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList, &Number::isEven, NumberSumReduce());
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::blockingFilteredReduced<int>(QLinkedList<Number>(numberLinkedList),
-                                                              &Number::isEven,
-                                                              NumberSumReduce());
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList.begin(),
-                                                             numberLinkedList.end(),
-                                                             &Number::isEven,
-                                                             NumberSumReduce());
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList.constBegin(),
-                                                             numberLinkedList.constEnd(),
-                                                             &Number::isEven,
-                                                             NumberSumReduce());
-        QCOMPARE(sum, 6);
-    }
-
-    // member-member
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers,
-                                                                        &Number::isEven,
-                                                                        &QLinkedList<Number>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers.begin(),
-                                                                        numbers.end(),
-                                                                        &Number::isEven,
-                                                                        &QLinkedList<Number>::append,
-                                                                        QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers.constBegin(),
-                                                                        numbers.constEnd(),
-                                                                        &Number::isEven,
-                                                                        &QLinkedList<Number>::append,
-                                                                        QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers,
-                                                                                &Number::isEven,
-                                                                                &QLinkedList<Number>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers.begin(),
-                                                                                numbers.end(),
-                                                                                &Number::isEven,
-                                                                                &QLinkedList<Number>::append,
-                                                                                QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-    {
-        QLinkedList<Number> numbers;
-        numbers << 1 << 2 << 3 << 4;
-        QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(),
-                                                                                numbers.constEnd(),
-                                                                                &Number::isEven,
-                                                                                &QLinkedList<Number>::append,
-                                                                                QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4);
-    }
-
-    // function-member
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList, keepEvenIntegers, &QLinkedList<int>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.begin(),
-                                                                     linkedList.end(),
-                                                                     keepEvenIntegers,
-                                                                     &QLinkedList<int>::append,
-                                                                     QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.constBegin(),
-                                                                     linkedList.constEnd(),
-                                                                     keepEvenIntegers,
-                                                                     &QLinkedList<int>::append,
-                                                                     QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList, keepEvenIntegers, &QLinkedList<int>::append, QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.begin(),
-                                                                             linkedList.end(),
-                                                                             keepEvenIntegers,
-                                                                             &QLinkedList<int>::append,
-                                                                             QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-    {
-        QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(),
-                                                                             linkedList.constEnd(),
-                                                                             keepEvenIntegers,
-                                                                             &QLinkedList<int>::append,
-                                                                             QtConcurrent::OrderedReduce);
-        QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4);
-    }
-
-    // member-function
-    {
-        int sum = QtConcurrent::filteredReduced(numberLinkedList, &Number::isEven, numberSumReduce);
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::filteredReduced(QLinkedList<Number>(numberLinkedList),
-                                                 &Number::isEven,
-                                                 numberSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(numberLinkedList.begin(),
-                                                numberLinkedList.end(),
-                                                &Number::isEven,
-                                                numberSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::filteredReduced(numberLinkedList.constBegin(),
-                                                numberLinkedList.constEnd(),
-                                                &Number::isEven,
-                                                numberSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList, &Number::isEven, numberSumReduce);
-        QCOMPARE(sum, 6);
-
-        int sum2 = QtConcurrent::blockingFilteredReduced(QLinkedList<Number>(numberLinkedList),
-                                                         &Number::isEven,
-                                                         numberSumReduce);
-        QCOMPARE(sum2, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList.begin(),
-                                                        numberLinkedList.end(),
-                                                        &Number::isEven,
-                                                        numberSumReduce);
-        QCOMPARE(sum, 6);
-    }
-    {
-        int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList.constBegin(),
-                                                        numberLinkedList.constEnd(),
-                                                        &Number::isEven,
-                                                        numberSumReduce);
-        QCOMPARE(sum, 6);
-    }
-
     // ### the same as above, with an initial result value
 }