Enable setting custom QThreadPool for QtConcurrent methods

Task-number: QTBUG-53465
Change-Id: Icff05d5f65dce453ff702502b85c35e20fca86a9
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>

4 files changed, 589 insertions, 7 deletions

diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
index 6e01542a57..dbcb0a1e9a 100644
--- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
+++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp
@@ -38,10 +38,14 @@ class tst_QtConcurrentFilter : public QObject
 
 private slots:
     void filter();
+    void filterThreadPool();
     void filtered();
+    void filteredThreadPool();
     void filteredReduced();
+    void filteredReducedThreadPool();
     void filteredReducedDifferentType();
     void filteredReducedInitialValue();
+    void filteredReducedInitialValueThreadPool();
     void filteredReducedDifferentTypeInitialValue();
     void resultAt();
     void incrementalResults();
@@ -96,6 +100,85 @@ void tst_QtConcurrentFilter::filter()
     CHECK_FAIL("lambda");
 }
 
+static QSemaphore semaphore(1);
+static QSet<QThread *> workingThreads;
+
+void storeCurrentThread()
+{
+    semaphore.acquire();
+    workingThreads.insert(QThread::currentThread());
+    semaphore.release();
+}
+
+int threadCount()
+{
+    semaphore.acquire();
+    const int count = workingThreads.size();
+    semaphore.release();
+    return count;
+}
+
+template <typename SourceObject,
+          typename ResultObject,
+          typename FilterObject>
+void testFilterThreadPool(QThreadPool *pool,
+                          const QList<SourceObject> &sourceObjectList,
+                          const QList<ResultObject> &expectedResult,
+                          FilterObject filterObject)
+{
+    QList<SourceObject> copy1 = sourceObjectList;
+//    QList<SourceObject> copy2 = sourceObjectList;
+
+    QtConcurrent::filter(pool, copy1, filterObject).waitForFinished();
+    QCOMPARE(copy1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    QtConcurrent::blockingFilter(pool, copy2, filterObject);
+//    QCOMPARE(copy2, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+class KeepOddIntegers
+{
+public:
+    bool operator()(const int &x)
+    {
+        storeCurrentThread();
+        return x & 1;
+    }
+};
+
+bool keepOddIntegers(const int &x)
+{
+    storeCurrentThread();
+    return x & 1;
+}
+
+void tst_QtConcurrentFilter::filterThreadPool()
+{
+    const QList<int> intList {1, 2, 3, 4};
+    const QList<int> intListEven {1, 3};
+
+    auto lambdaIsOdd = [](const int &x) {
+        storeCurrentThread();
+        return x & 1;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    testFilterThreadPool(&pool, intList, intListEven, KeepOddIntegers());
+    CHECK_FAIL("functor");
+    testFilterThreadPool(&pool, intList, intListEven, keepOddIntegers);
+    CHECK_FAIL("function");
+    testFilterThreadPool(&pool, intList, intListEven, lambdaIsOdd);
+    CHECK_FAIL("lambda");
+}
+
 template <typename SourceObject,
           typename ResultObject,
           typename FilterObject>
@@ -144,6 +227,61 @@ void tst_QtConcurrentFilter::filtered()
 
 template <typename SourceObject,
           typename ResultObject,
+          typename FilterObject>
+void testFilteredThreadPool(QThreadPool *pool,
+                            const QList<SourceObject> &sourceObjectList,
+                            const QList<ResultObject> &expectedResult,
+                            FilterObject filterObject)
+{
+    const QList<ResultObject> result1 = QtConcurrent::filtered(
+                pool, sourceObjectList, filterObject).results();
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const QList<ResultObject> result2 = QtConcurrent::filtered(
+                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                filterObject).results();
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const QList<ResultObject> result3 = QtConcurrent::blockingFiltered(
+//                pool, sourceObjectList, filterObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const QList<ResultObject> result4 = QtConcurrent::blockingFiltered<QList<ResultObject>>(
+//                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(), filterObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+void tst_QtConcurrentFilter::filteredThreadPool()
+{
+    const QList<int> intList {1, 2, 3, 4};
+    const QList<int> intListEven {1, 3};
+
+    auto lambdaIsOdd = [](const int &x) {
+        storeCurrentThread();
+        return x & 1;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    testFilteredThreadPool(&pool, intList, intListEven, KeepOddIntegers());
+    CHECK_FAIL("functor");
+    testFilteredThreadPool(&pool, intList, intListEven, keepOddIntegers);
+    CHECK_FAIL("function");
+    testFilteredThreadPool(&pool, intList, intListEven, lambdaIsOdd);
+    CHECK_FAIL("lambda");
+}
+
+template <typename SourceObject,
+          typename ResultObject,
           typename FilterObject,
           typename ReduceObject>
 void testFilteredReduced(const QList<SourceObject> &sourceObjectList,
@@ -277,6 +415,84 @@ void tst_QtConcurrentFilter::filteredReduced()
     CHECK_FAIL("lambda-lambda");
 }
 
+template <typename SourceObject,
+          typename ResultObject,
+          typename FilterObject,
+          typename ReduceObject>
+void testFilteredReducedThreadPool(QThreadPool *pool,
+                                   const QList<SourceObject> &sourceObjectList,
+                                   const ResultObject &expectedResult,
+                                   FilterObject filterObject,
+                                   ReduceObject reduceObject)
+{
+    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                pool, sourceObjectList, filterObject, reduceObject);
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
+                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                filterObject, reduceObject);
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+//                pool, sourceObjectList, filterObject, reduceObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+//                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+//                filterObject, reduceObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+void tst_QtConcurrentFilter::filteredReducedThreadPool()
+{
+    const QList<int> intList {1, 2, 3, 4};
+    const int intSum = 4; // sum of even values
+
+    auto lambdaIsOdd = [](const int &x) {
+        storeCurrentThread();
+        return x & 1;
+    };
+    auto lambdaSumReduce = [](int &sum, const int &x) {
+        sum += x;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    // FUNCTOR-other
+    testFilteredReducedThreadPool(&pool, intList, intSum, KeepOddIntegers(), IntSumReduce());
+    CHECK_FAIL("functor-functor");
+    testFilteredReducedThreadPool(&pool, intList, intSum, KeepOddIntegers(), intSumReduce);
+    CHECK_FAIL("functor-function");
+    testFilteredReducedThreadPool(&pool, intList, intSum, KeepOddIntegers(), lambdaSumReduce);
+    CHECK_FAIL("functor-lambda");
+
+    // FUNCTION-other
+    testFilteredReducedThreadPool(&pool, intList, intSum, keepOddIntegers, IntSumReduce());
+    CHECK_FAIL("function-functor");
+    testFilteredReducedThreadPool(&pool, intList, intSum, keepOddIntegers, intSumReduce);
+    CHECK_FAIL("function-function");
+    testFilteredReducedThreadPool(&pool, intList, intSum, keepOddIntegers, lambdaSumReduce);
+    CHECK_FAIL("function-lambda");
+
+    // LAMBDA-other
+    testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, IntSumReduce());
+    CHECK_FAIL("lambda-functor");
+    testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, intSumReduce);
+    CHECK_FAIL("lambda-function");
+    testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, lambdaSumReduce);
+    CHECK_FAIL("lambda-lambda");
+}
+
 void tst_QtConcurrentFilter::filteredReducedDifferentType()
 {
     const QList<Number> numberList {1, 2, 3, 4};
@@ -472,6 +688,96 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue()
     CHECK_FAIL("lambda-lambda");
 }
 
+template <typename SourceObject,
+          typename ResultObject,
+          typename InitialObject,
+          typename FilterObject,
+          typename ReduceObject>
+void testFilteredReducedInitialValueThreadPool(QThreadPool *pool,
+                                               const QList<SourceObject> &sourceObjectList,
+                                               const ResultObject &expectedResult,
+                                               FilterObject filterObject,
+                                               ReduceObject reduceObject,
+                                               InitialObject &&initialObject)
+{
+    const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>(
+                pool, sourceObjectList, filterObject, reduceObject, initialObject);
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>(
+                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                filterObject, reduceObject, initialObject);
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+//                pool, sourceObjectList, filterObject, reduceObject, initialObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>(
+//                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+//                filterObject, reduceObject, initialObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+void tst_QtConcurrentFilter::filteredReducedInitialValueThreadPool()
+{
+    const QList<int> intList {1, 2, 3, 4};
+    const int intInitial = 10;
+    const int intSum = 14; // sum of even values and initial value
+
+    auto lambdaIsOdd = [](const int &x) {
+        storeCurrentThread();
+        return x & 1;
+    };
+    auto lambdaSumReduce = [](int &sum, const int &x) {
+        sum += x;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    // FUNCTOR-other
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, KeepOddIntegers(),
+                                              IntSumReduce(), intInitial);
+    CHECK_FAIL("functor-functor");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, KeepOddIntegers(),
+                                              intSumReduce, intInitial);
+    CHECK_FAIL("functor-function");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, KeepOddIntegers(),
+                                              lambdaSumReduce, intInitial);
+    CHECK_FAIL("functor-lambda");
+
+    // FUNCTION-other
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, keepOddIntegers,
+                                              IntSumReduce(), intInitial);
+    CHECK_FAIL("function-functor");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, keepOddIntegers,
+                                              intSumReduce, intInitial);
+    CHECK_FAIL("function-function");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, keepOddIntegers,
+                                              lambdaSumReduce, intInitial);
+    CHECK_FAIL("function-lambda");
+
+    // LAMBDA-other
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, lambdaIsOdd,
+                                              IntSumReduce(), intInitial);
+    CHECK_FAIL("lambda-functor");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, lambdaIsOdd,
+                                              intSumReduce, intInitial);
+    CHECK_FAIL("lambda-function");
+    testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, lambdaIsOdd,
+                                              lambdaSumReduce, intInitial);
+    CHECK_FAIL("lambda-lambda");
+}
+
 void tst_QtConcurrentFilter::filteredReducedDifferentTypeInitialValue()
 {
     const QList<Number> numberList {1, 2, 3, 4};
diff --git a/tests/auto/concurrent/qtconcurrentiteratekernel/tst_qtconcurrentiteratekernel.cpp b/tests/auto/concurrent/qtconcurrentiteratekernel/tst_qtconcurrentiteratekernel.cpp
index 3c77b1ba0b..3dd77ed3d0 100644
--- a/tests/auto/concurrent/qtconcurrentiteratekernel/tst_qtconcurrentiteratekernel.cpp
+++ b/tests/auto/concurrent/qtconcurrentiteratekernel/tst_qtconcurrentiteratekernel.cpp
@@ -88,7 +88,7 @@ QAtomicInt iterations;
 class PrintFor : public IterateKernel<TestIterator, void>
 {
 public:
-    PrintFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(begin, end) { iterations.storeRelaxed(0); }
+    PrintFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(QThreadPool::globalInstance(), begin, end) { iterations.storeRelaxed(0); }
     bool runIterations(TestIterator/*beginIterator*/, int begin, int end, void *)
     {
         iterations.fetchAndAddRelaxed(end - begin);
@@ -107,7 +107,7 @@ public:
 class SleepPrintFor : public IterateKernel<TestIterator, void>
 {
 public:
-    SleepPrintFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(begin, end) { iterations.storeRelaxed(0); }
+    SleepPrintFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(QThreadPool::globalInstance(), begin, end) { iterations.storeRelaxed(0); }
     inline bool runIterations(TestIterator/*beginIterator*/, int begin, int end, void *)
     {
         QTest::qSleep(200);
@@ -147,7 +147,7 @@ QAtomicInt counter;
 class CountFor : public IterateKernel<TestIterator, void>
 {
 public:
-    CountFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(begin, end) { iterations.storeRelaxed(0); }
+    CountFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(QThreadPool::globalInstance(), begin, end) { iterations.storeRelaxed(0); }
     inline bool runIterations(TestIterator/*beginIterator*/, int begin, int end, void *)
     {
         counter.fetchAndAddRelaxed(end - begin);
@@ -175,7 +175,7 @@ void tst_QtConcurrentIterateKernel::noIterations()
 {
     const int times = 20000;
     for (int i = 0; i < times; ++i)
-        startThreadEngine(new IterateKernel<TestIterator, void>(0, 0)).startBlocking();
+        startThreadEngine(new IterateKernel<TestIterator, void>(QThreadPool::globalInstance(), 0, 0)).startBlocking();
 }
 
 QMutex threadsMutex;
@@ -186,7 +186,7 @@ public:
     // this class throttles between iterations 100 and 200,
     // and then records how many threads that run between
     // iterations 140 and 160.
-    ThrottleFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(begin, end) { iterations.storeRelaxed(0); throttling = false; }
+    ThrottleFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, void>(QThreadPool::globalInstance(), begin, end) { iterations.storeRelaxed(0); throttling = false; }
     inline bool runIterations(TestIterator/*beginIterator*/, int begin, int end, void *)
     {
         if (200 >= begin && 200 < end) {
@@ -242,7 +242,7 @@ void tst_QtConcurrentIterateKernel::throttling()
 class MultipleResultsFor : public IterateKernel<TestIterator, int>
 {
 public:
-    MultipleResultsFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, int>(begin, end) { }
+    MultipleResultsFor(TestIterator begin, TestIterator end) : IterateKernel<TestIterator, int>(QThreadPool::globalInstance(), begin, end) { }
     inline bool runIterations(TestIterator, int begin, int end, int *results)
     {
         for (int i = begin; i < end; ++i)
diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
index 111bc7fdad..9d904b6984 100644
--- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
+++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp
@@ -43,9 +43,12 @@ private slots:
     void map();
     void blocking_map();
     void mapped();
+    void mappedThreadPool();
     void mappedReduced();
+    void mappedReducedThreadPool();
     void mappedReducedDifferentType();
     void mappedReducedInitialValue();
+    void mappedReducedInitialValueThreadPool();
     void mappedReducedDifferentTypeInitialValue();
     void assignResult();
     void functionOverloads();
@@ -446,6 +449,92 @@ void tst_QtConcurrentMap::mapped()
 #endif
 }
 
+static QSemaphore semaphore(1);
+static QSet<QThread *> workingThreads;
+
+void storeCurrentThread()
+{
+    semaphore.acquire();
+    workingThreads.insert(QThread::currentThread());
+    semaphore.release();
+}
+
+int threadCount()
+{
+    semaphore.acquire();
+    const int count = workingThreads.size();
+    semaphore.release();
+    return count;
+}
+
+template <typename SourceObject, typename ResultObject, typename MapObject>
+void testMappedThreadPool(QThreadPool *pool,
+                          const QList<SourceObject> &sourceObjectList,
+                          const QList<ResultObject> &expectedResult,
+                          MapObject mapObject)
+{
+    const QList<ResultObject> result1 = QtConcurrent::mapped(pool,
+                sourceObjectList, mapObject).results();
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const QList<ResultObject> result2 = QtConcurrent::mapped(pool,
+                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject).results();
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const QList<ResultObject> result3 = QtConcurrent::blockingMapped(pool,
+//                sourceObjectList, mapObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const QList<ResultObject> result4 = QtConcurrent::blockingMapped<QList<ResultObject>>(pool,
+//                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+int multiplyBy3(int x)
+{
+    storeCurrentThread();
+    return x * 3;
+}
+
+class MultiplyBy3
+{
+public:
+    int operator()(int x) const
+    {
+        storeCurrentThread();
+        return x * 3;
+    }
+};
+
+void tst_QtConcurrentMap::mappedThreadPool()
+{
+    const QList<int> intList {1, 2, 3};
+    const QList<int> intListMultipiedBy3 {3, 6, 9};
+
+    auto lambdaMultiplyBy3 = [](int x) {
+        storeCurrentThread();
+        return x * 3;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    testMappedThreadPool(&pool, intList, intListMultipiedBy3, MultiplyBy3());
+    CHECK_FAIL("functor");
+    testMappedThreadPool(&pool, intList, intListMultipiedBy3, multiplyBy3);
+    CHECK_FAIL("function");
+    testMappedThreadPool(&pool, intList, intListMultipiedBy3, lambdaMultiplyBy3);
+    CHECK_FAIL("lambda");
+}
+
 int intSquare(int x)
 {
     return x * x;
@@ -572,6 +661,94 @@ void tst_QtConcurrentMap::mappedReduced()
     CHECK_FAIL("lambda-lambda");
 }
 
+template <typename SourceObject, typename ResultObject, typename MapObject, typename ReduceObject>
+void testMappedReducedThreadPool(QThreadPool *pool,
+                                 const QList<SourceObject> &sourceObjectList,
+                                 const ResultObject &expectedResult,
+                                 MapObject mapObject,
+                                 ReduceObject reduceObject)
+{
+    const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(pool,
+                sourceObjectList, mapObject, reduceObject);
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(pool,
+                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(pool,
+//                sourceObjectList, mapObject, reduceObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(pool,
+//                sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+int intCube(int x)
+{
+    storeCurrentThread();
+    return x * x * x;
+}
+
+class IntCube
+{
+public:
+    int operator()(int x)
+    {
+        storeCurrentThread();
+        return x * x * x;
+    }
+};
+
+void tst_QtConcurrentMap::mappedReducedThreadPool()
+{
+    const QList<int> intList {1, 2, 3};
+    const int sumOfCubes = 36;
+
+    auto lambdaCube = [](int x) {
+        return x * x * x;
+    };
+    auto lambdaSumReduce = [](int &sum, int x) {
+        sum += x;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    // FUNCTOR-other
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, IntCube(), IntSumReduce());
+    CHECK_FAIL("functor-functor");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, IntCube(), intSumReduce);
+    CHECK_FAIL("functor-function");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, IntCube(), lambdaSumReduce);
+    CHECK_FAIL("functor-lambda");
+
+    // FUNCTION-other
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, intCube, IntSumReduce());
+    CHECK_FAIL("function-functor");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, intCube, intSumReduce);
+    CHECK_FAIL("function-function");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, intCube, lambdaSumReduce);
+    CHECK_FAIL("function-lambda");
+
+    // LAMBDA-other
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, lambdaCube, IntSumReduce());
+    CHECK_FAIL("lambda-functor");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, lambdaCube, intSumReduce);
+    CHECK_FAIL("lambda-function");
+    testMappedReducedThreadPool(&pool, intList, sumOfCubes, lambdaCube, lambdaSumReduce);
+    CHECK_FAIL("lambda-lambda");
+}
+
 void tst_QtConcurrentMap::mappedReducedDifferentType()
 {
     const QList<int> intList {1, 2, 3};
@@ -734,6 +911,93 @@ void tst_QtConcurrentMap::mappedReducedInitialValue()
     CHECK_FAIL("lambda-lambda");
 }
 
+template <typename SourceObject, typename ResultObject, typename InitialObject, typename MapObject, typename ReduceObject>
+void testMappedReducedInitialValueThreadPool(QThreadPool *pool,
+                                             const QList<SourceObject> &sourceObjectList,
+                                             const ResultObject &expectedResult,
+                                             MapObject mapObject,
+                                             ReduceObject reduceObject,
+                                             InitialObject &&initialObject)
+{
+    const ResultObject result1 = QtConcurrent::mappedReduced<ResultObject>(
+                pool, sourceObjectList, mapObject, reduceObject, initialObject);
+    QCOMPARE(result1, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+    const ResultObject result2 = QtConcurrent::mappedReduced<ResultObject>(
+                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+                mapObject, reduceObject, initialObject);
+    QCOMPARE(result2, expectedResult);
+    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+// TODO: enable when QTBUG-83918 is fixed
+
+//    const ResultObject result3 = QtConcurrent::blockingMappedReduced<ResultObject>(
+//                pool, sourceObjectList, mapObject, reduceObject, initialObject);
+//    QCOMPARE(result3, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+
+//    const ResultObject result4 = QtConcurrent::blockingMappedReduced<ResultObject>(
+//                pool, sourceObjectList.constBegin(), sourceObjectList.constEnd(),
+//                mapObject, reduceObject, initialObject);
+//    QCOMPARE(result4, expectedResult);
+//    QCOMPARE(threadCount(), 1); // ensure the only one thread was working
+}
+
+void tst_QtConcurrentMap::mappedReducedInitialValueThreadPool()
+{
+    // This is a copy of tst_QtConcurrentMap::mappedReduced with the initial value parameter added
+
+    const QList<int> intList {1, 2, 3};
+    const int sumOfCubes = 46;
+    const int intInitial = 10;
+
+    auto lambdaCube = [](int x) {
+        return x * x * x;
+    };
+    auto lambdaSumReduce = [](int &sum, int x) {
+        sum += x;
+    };
+
+    QThreadPool pool;
+    pool.setMaxThreadCount(1);
+    QCOMPARE(semaphore.available(), 1);
+    workingThreads.clear();
+
+    // FUNCTOR-other
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, IntCube(),
+                                            IntSumReduce(), intInitial);
+    CHECK_FAIL("functor-functor");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, IntCube(),
+                                            intSumReduce, intInitial);
+    CHECK_FAIL("functor-function");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, IntCube(),
+                                            lambdaSumReduce, intInitial);
+    CHECK_FAIL("functor-lambda");
+
+    // FUNCTION-other
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, intCube,
+                                            IntSumReduce(), intInitial);
+    CHECK_FAIL("function-functor");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, intCube,
+                                            intSumReduce, intInitial);
+    CHECK_FAIL("function-function");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, intCube,
+                                            lambdaSumReduce, intInitial);
+    CHECK_FAIL("function-lambda");
+
+    // LAMBDA-other
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, lambdaCube,
+                                            IntSumReduce(), intInitial);
+    CHECK_FAIL("lambda-functor");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, lambdaCube,
+                                            intSumReduce, intInitial);
+    CHECK_FAIL("lambda-function");
+    testMappedReducedInitialValueThreadPool(&pool, intList, sumOfCubes, lambdaCube,
+                                            lambdaSumReduce, intInitial);
+    CHECK_FAIL("lambda-lambda");
+}
+
 void tst_QtConcurrentMap::mappedReducedDifferentTypeInitialValue()
 {
     // This is a copy of tst_QtConcurrentMap::mappedReducedDifferentType
diff --git a/tests/auto/concurrent/qtconcurrentthreadengine/tst_qtconcurrentthreadengine.cpp b/tests/auto/concurrent/qtconcurrentthreadengine/tst_qtconcurrentthreadengine.cpp
index d4c669cddc..e192dad3bd 100644
--- a/tests/auto/concurrent/qtconcurrentthreadengine/tst_qtconcurrentthreadengine.cpp
+++ b/tests/auto/concurrent/qtconcurrentthreadengine/tst_qtconcurrentthreadengine.cpp
@@ -55,6 +55,7 @@ private slots:
 class PrintUser : public ThreadEngine<void>
 {
 public:
+    PrintUser() : ThreadEngine(QThreadPool::globalInstance()) {}
     ThreadFunctionResult threadFunction()
     {
         QTest::qSleep(50);
@@ -82,7 +83,8 @@ class StringResultUser : public ThreadEngine<QString>
 public:
     typedef QString ResultType;
     StringResultUser()
-    : done(false) { }
+    : ThreadEngine(QThreadPool::globalInstance())
+    , done(false) { }
 
     bool shouldStartThread()
     {
@@ -113,6 +115,8 @@ void tst_QtConcurrentThreadEngine::result()
 class VoidResultUser : public ThreadEngine<void>
 {
 public:
+    VoidResultUser() : ThreadEngine(QThreadPool::globalInstance()) {}
+
     bool shouldStartThread()
     {
         return !done;
@@ -149,6 +153,8 @@ void tst_QtConcurrentThreadEngine::runThroughStarter()
 class CancelUser : public ThreadEngine<void>
 {
 public:
+    CancelUser() : ThreadEngine(QThreadPool::globalInstance()) {}
+
     void *result()
     {
         return 0;
@@ -186,6 +192,7 @@ class ThrottleAlwaysUser : public ThreadEngine<void>
 {
 public:
     ThrottleAlwaysUser()
+    : ThreadEngine(QThreadPool::globalInstance())
     {
         count.storeRelaxed(initialCount = 100);
         finishing = false;
@@ -240,6 +247,7 @@ class ThreadCountUser : public ThreadEngine<void>
 {
 public:
     ThreadCountUser(bool finishImmediately = false)
+    : ThreadEngine(QThreadPool::globalInstance())
     {
         threads.clear();
         finishing = finishImmediately;
@@ -306,6 +314,7 @@ void tst_QtConcurrentThreadEngine::threadCount()
 class MultipleResultsUser : public ThreadEngine<int>
 {
 public:
+    MultipleResultsUser() : ThreadEngine(QThreadPool::globalInstance()) {}
     bool shouldStartThread()
     {
         return false;
@@ -375,6 +384,7 @@ const int sleepTime = 20;
 class SlowUser : public ThreadEngine<void>
 {
 public:
+    SlowUser() : ThreadEngine(QThreadPool::globalInstance()) {}
     bool shouldStartThread() { return false; }
     ThreadFunctionResult threadFunction() { QTest::qSleep(sleepTime); return ThreadFinished; }
 };
@@ -406,6 +416,7 @@ class QtConcurrentExceptionThrower : public ThreadEngine<void>
 {
 public:
     QtConcurrentExceptionThrower(QThread *blockThread = 0)
+    : ThreadEngine(QThreadPool::globalInstance())
     {
         this->blockThread = blockThread;
     }
@@ -423,6 +434,7 @@ class UnrelatedExceptionThrower : public ThreadEngine<void>
 {
 public:
     UnrelatedExceptionThrower(QThread *blockThread = 0)
+    : ThreadEngine(QThreadPool::globalInstance())
     {
         this->blockThread = blockThread;
     }