From 8a11641bb9709b2c6cb5051163eb5086838c8fac Mon Sep 17 00:00:00 2001 From: Jarek Kobus Date: Tue, 28 Apr 2020 14:19:42 +0200 Subject: Enable setting custom QThreadPool for QtConcurrent methods Task-number: QTBUG-53465 Change-Id: Icff05d5f65dce453ff702502b85c35e20fca86a9 Reviewed-by: Sona Kurazyan --- .../qtconcurrentfilter/tst_qtconcurrentfilter.cpp | 306 +++++++++++++++++++++ .../tst_qtconcurrentiteratekernel.cpp | 12 +- .../qtconcurrentmap/tst_qtconcurrentmap.cpp | 264 ++++++++++++++++++ .../tst_qtconcurrentthreadengine.cpp | 14 +- 4 files changed, 589 insertions(+), 7 deletions(-) (limited to 'tests') 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 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 +void testFilterThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const QList &expectedResult, + FilterObject filterObject) +{ + QList copy1 = sourceObjectList; +// QList 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 intList {1, 2, 3, 4}; + const QList 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 @@ -142,6 +225,61 @@ void tst_QtConcurrentFilter::filtered() CHECK_FAIL("lambda"); } +template +void testFilteredThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const QList &expectedResult, + FilterObject filterObject) +{ + const QList result1 = QtConcurrent::filtered( + pool, sourceObjectList, filterObject).results(); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const QList 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 result3 = QtConcurrent::blockingFiltered( +// pool, sourceObjectList, filterObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const QList result4 = QtConcurrent::blockingFiltered>( +// 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 intList {1, 2, 3, 4}; + const QList 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 +void testFilteredReducedThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const ResultObject &expectedResult, + FilterObject filterObject, + ReduceObject reduceObject) +{ + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const ResultObject result2 = QtConcurrent::filteredReduced( + 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( +// pool, sourceObjectList, filterObject, reduceObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const ResultObject result4 = QtConcurrent::blockingFilteredReduced( +// 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 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 numberList {1, 2, 3, 4}; @@ -472,6 +688,96 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue() CHECK_FAIL("lambda-lambda"); } +template +void testFilteredReducedInitialValueThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const ResultObject &expectedResult, + FilterObject filterObject, + ReduceObject reduceObject, + InitialObject &&initialObject) +{ + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject, initialObject); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const ResultObject result2 = QtConcurrent::filteredReduced( + 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( +// pool, sourceObjectList, filterObject, reduceObject, initialObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const ResultObject result4 = QtConcurrent::blockingFilteredReduced( +// 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 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 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 { public: - PrintFor(TestIterator begin, TestIterator end) : IterateKernel(begin, end) { iterations.storeRelaxed(0); } + PrintFor(TestIterator begin, TestIterator end) : IterateKernel(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 { public: - SleepPrintFor(TestIterator begin, TestIterator end) : IterateKernel(begin, end) { iterations.storeRelaxed(0); } + SleepPrintFor(TestIterator begin, TestIterator end) : IterateKernel(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 { public: - CountFor(TestIterator begin, TestIterator end) : IterateKernel(begin, end) { iterations.storeRelaxed(0); } + CountFor(TestIterator begin, TestIterator end) : IterateKernel(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(0, 0)).startBlocking(); + startThreadEngine(new IterateKernel(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(begin, end) { iterations.storeRelaxed(0); throttling = false; } + ThrottleFor(TestIterator begin, TestIterator end) : IterateKernel(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 { public: - MultipleResultsFor(TestIterator begin, TestIterator end) : IterateKernel(begin, end) { } + MultipleResultsFor(TestIterator begin, TestIterator end) : IterateKernel(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 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 +void testMappedThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const QList &expectedResult, + MapObject mapObject) +{ + const QList result1 = QtConcurrent::mapped(pool, + sourceObjectList, mapObject).results(); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const QList 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 result3 = QtConcurrent::blockingMapped(pool, +// sourceObjectList, mapObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const QList result4 = QtConcurrent::blockingMapped>(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 intList {1, 2, 3}; + const QList 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 +void testMappedReducedThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const ResultObject &expectedResult, + MapObject mapObject, + ReduceObject reduceObject) +{ + const ResultObject result1 = QtConcurrent::mappedReduced(pool, + sourceObjectList, mapObject, reduceObject); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const ResultObject result2 = QtConcurrent::mappedReduced(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(pool, +// sourceObjectList, mapObject, reduceObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const ResultObject result4 = QtConcurrent::blockingMappedReduced(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 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 intList {1, 2, 3}; @@ -734,6 +911,93 @@ void tst_QtConcurrentMap::mappedReducedInitialValue() CHECK_FAIL("lambda-lambda"); } +template +void testMappedReducedInitialValueThreadPool(QThreadPool *pool, + const QList &sourceObjectList, + const ResultObject &expectedResult, + MapObject mapObject, + ReduceObject reduceObject, + InitialObject &&initialObject) +{ + const ResultObject result1 = QtConcurrent::mappedReduced( + pool, sourceObjectList, mapObject, reduceObject, initialObject); + QCOMPARE(result1, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + const ResultObject result2 = QtConcurrent::mappedReduced( + 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( +// pool, sourceObjectList, mapObject, reduceObject, initialObject); +// QCOMPARE(result3, expectedResult); +// QCOMPARE(threadCount(), 1); // ensure the only one thread was working + +// const ResultObject result4 = QtConcurrent::blockingMappedReduced( +// 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 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 { public: + PrintUser() : ThreadEngine(QThreadPool::globalInstance()) {} ThreadFunctionResult threadFunction() { QTest::qSleep(50); @@ -82,7 +83,8 @@ class StringResultUser : public ThreadEngine 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 { public: + VoidResultUser() : ThreadEngine(QThreadPool::globalInstance()) {} + bool shouldStartThread() { return !done; @@ -149,6 +153,8 @@ void tst_QtConcurrentThreadEngine::runThroughStarter() class CancelUser : public ThreadEngine { public: + CancelUser() : ThreadEngine(QThreadPool::globalInstance()) {} + void *result() { return 0; @@ -186,6 +192,7 @@ class ThrottleAlwaysUser : public ThreadEngine { public: ThrottleAlwaysUser() + : ThreadEngine(QThreadPool::globalInstance()) { count.storeRelaxed(initialCount = 100); finishing = false; @@ -240,6 +247,7 @@ class ThreadCountUser : public ThreadEngine { public: ThreadCountUser(bool finishImmediately = false) + : ThreadEngine(QThreadPool::globalInstance()) { threads.clear(); finishing = finishImmediately; @@ -306,6 +314,7 @@ void tst_QtConcurrentThreadEngine::threadCount() class MultipleResultsUser : public ThreadEngine { public: + MultipleResultsUser() : ThreadEngine(QThreadPool::globalInstance()) {} bool shouldStartThread() { return false; @@ -375,6 +384,7 @@ const int sleepTime = 20; class SlowUser : public ThreadEngine { public: + SlowUser() : ThreadEngine(QThreadPool::globalInstance()) {} bool shouldStartThread() { return false; } ThreadFunctionResult threadFunction() { QTest::qSleep(sleepTime); return ThreadFinished; } }; @@ -406,6 +416,7 @@ class QtConcurrentExceptionThrower : public ThreadEngine { public: QtConcurrentExceptionThrower(QThread *blockThread = 0) + : ThreadEngine(QThreadPool::globalInstance()) { this->blockThread = blockThread; } @@ -423,6 +434,7 @@ class UnrelatedExceptionThrower : public ThreadEngine { public: UnrelatedExceptionThrower(QThread *blockThread = 0) + : ThreadEngine(QThreadPool::globalInstance()) { this->blockThread = blockThread; } -- cgit v1.2.3