From d57adfe5f375121c3e233465526ee5d9df03e1e9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Nordheim?= <marten.nordheim@qt.io>
Date: Wed, 26 Feb 2020 18:06:49 +0100
Subject: QtConcurrent: filter- and map-reduce with initial value

It takes any type which is implictly covertible to the result type
and then converts it in the outer-layers. Then it passes it into the
deeper layers and initiales the result value.

One drive-by fix with a missing letter in the documentation.

[ChangeLog][QtConcurrent] QtConcurrent::mappedReduce and
QtConcurrent::filteredReduced, as well as their blocking variants,
now optionally take an initial value.

Fixes: QTBUG-73240
Change-Id: I7a80d96693cfa3374847c75c75b3167664609c1a
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>
Reviewed-by: Timur Pocheptsov <timur.pocheptsov@qt.io>
---
 .../qtconcurrentfilter/tst_qtconcurrentfilter.cpp  | 423 ++++++++++++++++++++-
 .../qtconcurrentmap/tst_qtconcurrentmap.cpp        | 370 +++++++++++++++++-
 2 files changed, 788 insertions(+), 5 deletions(-)

(limited to 'tests/auto/concurrent')

diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
index e6ac829230..1b52f52038 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
+++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
@@ -44,6 +44,7 @@ private slots:
     void incrementalResults();
     void noDetach();
     void stlContainers();
+    void filteredReduceInitialValue();
 };
 
 void tst_QtConcurrentFilter::filter()
@@ -728,7 +729,6 @@ void tst_QtConcurrentFilter::filteredReduced()
         QCOMPARE(sum, 6);
     }
 
-    // ### the same as above, with an initial result value
 }
 
 bool filterfn(int i)
@@ -857,5 +857,426 @@ void tst_QtConcurrentFilter::stlContainers()
     QCOMPARE(*list2.begin(), 1);
 }
 
+void tst_QtConcurrentFilter::filteredReduceInitialValue()
+{
+    // This test's the same as filteredReduce, but with an initial value on all calls
+    QList<int> list;
+    list << 1 << 2 << 3 << 4;
+    QList<Number> numberList;
+    numberList << 1 << 2 << 3 << 4;
+
+    // functor-functor
+    {
+        int sum = QtConcurrent::filteredReduced<int>(list, KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        QVector<int> vector;
+        vector << 1 << 2 << 3 << 4;
+        int sum =
+                QtConcurrent::filteredReduced<int>(vector, KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                list.begin(), list.end(), KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::filteredReduced<int>(
+                list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                list.constBegin(), list.constEnd(), KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::filteredReduced<int>(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list, KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::blockingFilteredReduced<int>(
+                list, keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list.begin(), list.end(), KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::blockingFilteredReduced<int>(
+                list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list.constBegin(), list.constEnd(), KeepEvenIntegers(), IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::blockingFilteredReduced<int>(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+
+    // function-functor
+    {
+        int sum = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                list.begin(), list.end(), keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list, keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list.begin(), list.end(), keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, IntSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+
+    // functor-function
+    {
+        int sum = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(
+                list.begin(), list.end(), KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(
+                list.constBegin(), list.constEnd(), KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                list.begin(), list.end(), KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                list.constBegin(), list.constEnd(), KeepEvenIntegers(), intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+
+    // function-function
+    {
+        int sum = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(
+                list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+
+    auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back);
+    // functor-member
+    QVector<int> initialIntVector;
+    initialIntVector.push_back(10);
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(
+                list, KeepEvenIntegers(), push_back, initialIntVector, QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(list.begin(),
+                                                         list.end(),
+                                                         KeepEvenIntegers(),
+                                                         push_back,
+                                                         initialIntVector,
+                                                         QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(),
+                                                         list.constEnd(),
+                                                         KeepEvenIntegers(),
+                                                         push_back,
+                                                         initialIntVector,
+                                                         QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(
+                list, KeepEvenIntegers(), push_back, initialIntVector, QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(),
+                                                                 list.end(),
+                                                                 KeepEvenIntegers(),
+                                                                 push_back,
+                                                                 initialIntVector,
+                                                                 QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(),
+                                                                 list.constEnd(),
+                                                                 KeepEvenIntegers(),
+                                                                 push_back,
+                                                                 initialIntVector,
+                                                                 QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+
+    // member-functor
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                numberList, &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::filteredReduced<int>(
+                QList<Number>(numberList), &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(
+                numberList.begin(), numberList.end(), &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced<int>(numberList.constBegin(),
+                                                     numberList.constEnd(),
+                                                     &Number::isEven,
+                                                     NumberSumReduce(),
+                                                     10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                numberList, &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::blockingFilteredReduced<int>(
+                QList<Number>(numberList), &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(
+                numberList.begin(), numberList.end(), &Number::isEven, NumberSumReduce(), 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced<int>(numberList.constBegin(),
+                                                             numberList.constEnd(),
+                                                             &Number::isEven,
+                                                             NumberSumReduce(),
+                                                             10);
+        QCOMPARE(sum, 16);
+    }
+
+    // member-member
+
+    auto push_back_number =
+            static_cast<void (QVector<Number>::*)(const Number &)>(&QVector<Number>::push_back);
+    QVector<Number> initialNumberVector { 10 };
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::filteredReduced(numbers,
+                                                            &Number::isEven,
+                                                            push_back_number,
+                                                            initialNumberVector,
+                                                            QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::filteredReduced(numbers.begin(),
+                                                            numbers.end(),
+                                                            &Number::isEven,
+                                                            push_back_number,
+                                                            initialNumberVector,
+                                                            QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::filteredReduced(numbers.constBegin(),
+                                                            numbers.constEnd(),
+                                                            &Number::isEven,
+                                                            push_back_number,
+                                                            initialNumberVector,
+                                                            QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers,
+                                                                    &Number::isEven,
+                                                                    push_back_number,
+                                                                    initialNumberVector,
+                                                                    QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.begin(),
+                                                                    numbers.end(),
+                                                                    &Number::isEven,
+                                                                    push_back_number,
+                                                                    initialNumberVector,
+                                                                    QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+    {
+        QList<Number> numbers;
+        numbers << 1 << 2 << 3 << 4;
+        QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(),
+                                                                    numbers.constEnd(),
+                                                                    &Number::isEven,
+                                                                    push_back_number,
+                                                                    initialNumberVector,
+                                                                    QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<Number>() << 10 << 2 << 4);
+    }
+
+    // function-member
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(
+                list, keepEvenIntegers, push_back, initialIntVector, QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(list.begin(),
+                                                         list.end(),
+                                                         keepEvenIntegers,
+                                                         push_back,
+                                                         initialIntVector,
+                                                         QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(),
+                                                         list.constEnd(),
+                                                         keepEvenIntegers,
+                                                         push_back,
+                                                         initialIntVector,
+                                                         QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(
+                list, keepEvenIntegers, push_back, initialIntVector, QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(),
+                                                                 list.end(),
+                                                                 keepEvenIntegers,
+                                                                 push_back,
+                                                                 initialIntVector,
+                                                                 QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+    {
+        QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(),
+                                                                 list.constEnd(),
+                                                                 keepEvenIntegers,
+                                                                 push_back,
+                                                                 initialIntVector,
+                                                                 QtConcurrent::OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 2 << 4);
+    }
+
+    // member-function
+    {
+        int sum = QtConcurrent::filteredReduced(numberList, &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::filteredReduced(
+                QList<Number>(numberList), &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(
+                numberList.begin(), numberList.end(), &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::filteredReduced(numberList.constBegin(),
+                                                numberList.constEnd(),
+                                                &Number::isEven,
+                                                numberSumReduce,
+                                                10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                numberList, &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum, 16);
+
+        int sum2 = QtConcurrent::blockingFilteredReduced(
+                QList<Number>(numberList), &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum2, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(
+                numberList.begin(), numberList.end(), &Number::isEven, numberSumReduce, 10);
+        QCOMPARE(sum, 16);
+    }
+    {
+        int sum = QtConcurrent::blockingFilteredReduced(numberList.constBegin(),
+                                                        numberList.constEnd(),
+                                                        &Number::isEven,
+                                                        numberSumReduce,
+                                                        10);
+        QCOMPARE(sum, 16);
+    }
+}
+
 QTEST_MAIN(tst_QtConcurrentFilter)
 #include "tst_qtconcurrentfilter.moc"
diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
index fbcac35fee..1a8978c7ea 100644
--- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
+++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
@@ -58,6 +58,8 @@ private slots:
     void qFutureAssignmentLeak();
     void stressTest();
     void persistentResultTest();
+    void mappedReducedInitialValue();
+    void blocking_mappedReducedInitialValue();
 public slots:
     void throttling();
 };
@@ -1084,8 +1086,6 @@ void tst_QtConcurrentMap::mappedReduced()
                                                intSumReduce);
         QCOMPARE(sum3, 6);
     }
-
-    // ### the same as above, with an initial result value
 }
 
 void tst_QtConcurrentMap::blocking_mappedReduced()
@@ -1271,8 +1271,6 @@ void tst_QtConcurrentMap::blocking_mappedReduced()
                                                intSumReduce);
         QCOMPARE(sum3, 6);
     }
-
-    // ### the same as above, with an initial result value
 }
 
 int sleeper(int val)
@@ -1767,5 +1765,369 @@ void tst_QtConcurrentMap::persistentResultTest()
     QCOMPARE(ref.loadAcquire(), 3);
 }
 
+void tst_QtConcurrentMap::mappedReducedInitialValue()
+{
+    // This is a copy of tst_QtConcurrentMap::mappedReduced with the initial value parameter added
+
+    QList<int> list;
+    list << 1 << 2 << 3;
+    QList<Number> numberList;
+    numberList << 1 << 2 << 3;
+
+    // test Q_DECLARE_OPERATORS_FOR_FLAGS
+    QtConcurrent::ReduceOptions opt =
+            (QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce);
+    QVERIFY(opt);
+
+    int initialValue = 10;
+    // functor-functor
+    {
+        int sum = QtConcurrent::mappedReduced<int>(list, IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::mappedReduced<int>(
+                list.constBegin(), list.constEnd(), IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::mappedReduced<int>(
+                QList<int>(list), IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 24);
+
+        int sum4 = QtConcurrent::mappedReduced<int>(list, intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum4, 24);
+        int sum5 = QtConcurrent::mappedReduced<int>(
+                list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum5, 24);
+
+        int sum6 = QtConcurrent::mappedReduced<int>(
+                QList<int>(list), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum6, 24);
+    }
+
+    // function-functor
+    {
+        int sum = QtConcurrent::mappedReduced<int>(list, intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::mappedReduced<int>(
+                list.constBegin(), list.constEnd(), intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::mappedReduced<int>(
+                QList<int>(list), intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    // functor-function
+    {
+        int sum = QtConcurrent::mappedReduced(list, IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::mappedReduced(
+                list.constBegin(), list.constEnd(), IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::mappedReduced(
+                QList<int>(list), IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    // function-function
+    {
+        int sum = QtConcurrent::mappedReduced(list, intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::mappedReduced(
+                list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::mappedReduced(
+                QList<int>(list), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back);
+
+    QVector<int> initialIntVector;
+    initialIntVector.push_back(10);
+    // functor-member
+    {
+        QList<int> list2 = QtConcurrent::mappedReduced(
+                list, IntSquare(), push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(),
+                                                       list.constEnd(),
+                                                       IntSquare(),
+                                                       push_back,
+                                                       initialIntVector,
+                                                       OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list4 = QtConcurrent::mappedReduced(
+                QList<int>(list), IntSquare(), push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9);
+    }
+
+    // member-functor
+    {
+        int sum = QtConcurrent::mappedReduced<int>(
+                numberList, &Number::toInt, IntSumReduce(), initialValue);
+        QCOMPARE(sum, 16);
+        int sum2 = QtConcurrent::mappedReduced<int>(numberList.constBegin(),
+                                                    numberList.constEnd(),
+                                                    &Number::toInt,
+                                                    IntSumReduce(),
+                                                    initialValue);
+        QCOMPARE(sum2, 16);
+
+        int sum3 = QtConcurrent::mappedReduced<int>(
+                QList<Number>(numberList), &Number::toInt, IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 16);
+    }
+
+    // member-member
+    {
+        QList<int> list2 = QtConcurrent::mappedReduced(
+                numberList, &Number::toInt, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 2 << 3);
+
+        QList<int> list3 = QtConcurrent::mappedReduced(numberList.constBegin(),
+                                                       numberList.constEnd(),
+                                                       &Number::toInt,
+                                                       push_back,
+                                                       initialIntVector,
+                                                       OrderedReduce);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 2 << 3);
+
+        QList<int> list4 = QtConcurrent::mappedReduced(QList<Number>(numberList),
+                                                       &Number::toInt,
+                                                       push_back,
+                                                       initialIntVector,
+                                                       OrderedReduce);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 2 << 3);
+    }
+
+    // function-member
+    {
+        QList<int> list2 = QtConcurrent::mappedReduced(
+                list, intSquare, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(),
+                                                       list.constEnd(),
+                                                       intSquare,
+                                                       push_back,
+                                                       initialIntVector,
+                                                       OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list4 = QtConcurrent::mappedReduced(
+                QList<int>(list), intSquare, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9);
+    }
+
+    // member-function
+    {
+        int sum =
+                QtConcurrent::mappedReduced(numberList, &Number::toInt, intSumReduce, initialValue);
+        QCOMPARE(sum, 16);
+        int sum2 = QtConcurrent::mappedReduced(numberList.constBegin(),
+                                               numberList.constEnd(),
+                                               &Number::toInt,
+                                               intSumReduce,
+                                               initialValue);
+        QCOMPARE(sum2, 16);
+
+        int sum3 = QtConcurrent::mappedReduced(
+                QList<Number>(numberList), &Number::toInt, intSumReduce, initialValue);
+        QCOMPARE(sum3, 16);
+    }
+}
+
+void tst_QtConcurrentMap::blocking_mappedReducedInitialValue()
+{
+    // This is a copy of tst_QtConcurrentMap::blocking_mappedReduced with the initial value
+    // parameter added
+
+    QList<int> list;
+    list << 1 << 2 << 3;
+    QList<Number> numberList;
+    numberList << 1 << 2 << 3;
+
+    int initialValue = 10;
+    // functor-functor
+    {
+        int sum = QtConcurrent::blockingMappedReduced<int>(
+                list, IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::blockingMappedReduced<int>(
+                list.constBegin(), list.constEnd(), IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::blockingMappedReduced<int>(
+                QList<int>(list), IntSquare(), IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 24);
+
+        int sum4 = QtConcurrent::blockingMappedReduced<int>(
+                list, intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum4, 24);
+        int sum5 = QtConcurrent::blockingMappedReduced<int>(
+                list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum5, 24);
+
+        int sum6 = QtConcurrent::blockingMappedReduced<int>(
+                QList<int>(list), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum6, 24);
+    }
+
+    // function-functor
+    {
+        int sum = QtConcurrent::blockingMappedReduced<int>(
+                list, intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::blockingMappedReduced<int>(
+                list.constBegin(), list.constEnd(), intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::blockingMappedReduced<int>(
+                QList<int>(list), intSquare, IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    // functor-function
+    {
+        int sum =
+                QtConcurrent::blockingMappedReduced(list, IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::blockingMappedReduced(
+                list.constBegin(), list.constEnd(), IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::blockingMappedReduced(
+                QList<int>(list), IntSquare(), intSumReduce, initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    // function-function
+    {
+        int sum = QtConcurrent::blockingMappedReduced(list, intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum, 24);
+        int sum2 = QtConcurrent::blockingMappedReduced(
+                list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum2, 24);
+
+        int sum3 = QtConcurrent::blockingMappedReduced(
+                QList<int>(list), intSquare, intSumReduce, initialValue);
+        QCOMPARE(sum3, 24);
+    }
+
+    auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back);
+
+    QVector<int> initialIntVector;
+    initialIntVector.push_back(10);
+    // functor-member
+    {
+        QList<int> list2 = QtConcurrent::blockingMappedReduced(
+                list, IntSquare(), push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(),
+                                                               list.constEnd(),
+                                                               IntSquare(),
+                                                               push_back,
+                                                               initialIntVector,
+                                                               OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list4 = QtConcurrent::blockingMappedReduced(
+                QList<int>(list), IntSquare(), push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9);
+    }
+
+    // member-functor
+    {
+        int sum = QtConcurrent::blockingMappedReduced<int>(
+                numberList, &Number::toInt, IntSumReduce(), initialValue);
+        QCOMPARE(sum, 16);
+        int sum2 = QtConcurrent::blockingMappedReduced<int>(numberList.constBegin(),
+                                                            numberList.constEnd(),
+                                                            &Number::toInt,
+                                                            IntSumReduce(),
+                                                            initialValue);
+        QCOMPARE(sum2, 16);
+
+        int sum3 = QtConcurrent::blockingMappedReduced<int>(
+                QList<Number>(numberList), &Number::toInt, IntSumReduce(), initialValue);
+        QCOMPARE(sum3, 16);
+    }
+
+    // member-member
+    {
+        QList<int> list2 = QtConcurrent::blockingMappedReduced(
+                numberList, &Number::toInt, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 2 << 3);
+
+        QList<int> list3 = QtConcurrent::blockingMappedReduced(numberList.constBegin(),
+                                                               numberList.constEnd(),
+                                                               &Number::toInt,
+                                                               push_back,
+                                                               initialIntVector,
+                                                               OrderedReduce);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 2 << 3);
+
+        QList<int> list4 = QtConcurrent::blockingMappedReduced(QList<Number>(numberList),
+                                                               &Number::toInt,
+                                                               push_back,
+                                                               initialIntVector,
+                                                               OrderedReduce);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 2 << 3);
+    }
+
+    // function-member
+    {
+        QList<int> list2 = QtConcurrent::blockingMappedReduced(
+                list, intSquare, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(),
+                                                               list.constEnd(),
+                                                               intSquare,
+                                                               push_back,
+                                                               initialIntVector,
+                                                               OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9);
+
+        QList<int> list4 = QtConcurrent::blockingMappedReduced(
+                QList<int>(list), intSquare, push_back, initialIntVector, OrderedReduce);
+        QCOMPARE(list, QList<int>() << 1 << 2 << 3);
+        QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9);
+    }
+
+    // member-function
+    {
+        int sum = QtConcurrent::blockingMappedReduced(
+                numberList, &Number::toInt, intSumReduce, initialValue);
+        QCOMPARE(sum, 16);
+        int sum2 = QtConcurrent::blockingMappedReduced(numberList.constBegin(),
+                                                       numberList.constEnd(),
+                                                       &Number::toInt,
+                                                       intSumReduce,
+                                                       initialValue);
+        QCOMPARE(sum2, 16);
+
+        int sum3 = QtConcurrent::blockingMappedReduced(
+                QList<Number>(numberList), &Number::toInt, intSumReduce, initialValue);
+        QCOMPARE(sum3, 16);
+    }
+}
+
 QTEST_MAIN(tst_QtConcurrentMap)
 #include "tst_qtconcurrentmap.moc"
-- 
cgit v1.2.3