From 6ebe3d0f0806069f906522dfe9b81baa3f3478de Mon Sep 17 00:00:00 2001 From: Sona Kurazyan Date: Sat, 10 Jul 2021 20:57:03 +0200 Subject: Fix QtConcurrent to properly work with functors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit QtConcurrent reduce functions were requiring to explicitly pass the the result type when passing functors as reductor. This was because of inability to deduce the result type from the functors. The result type of the QtConcurrent reduce functions should match with the type of the fist argument of the operator() when a functor is passed. Reused the ArgResolver type trait (already used for QFuture and QtConcurrent::run) to find out the result type in that case. Task-number: QTBUG-88448 Change-Id: Ief0eeee197df8cb9c30f3403d71978f36e4fb0f2 Reviewed-by: Qt CI Bot Reviewed-by: Mårten Nordheim --- src/concurrent/qtconcurrentfilter.h | 58 ++-- src/concurrent/qtconcurrentfunctionwrappers.h | 45 +++ src/concurrent/qtconcurrentmap.h | 69 ++--- .../qtconcurrentfilter/tst_qtconcurrentfilter.cpp | 328 ++++++++++++++------- .../qtconcurrentmap/tst_qtconcurrentmap.cpp | 300 +++++++++++++------ 5 files changed, 522 insertions(+), 278 deletions(-) diff --git a/src/concurrent/qtconcurrentfilter.h b/src/concurrent/qtconcurrentfilter.h index 891eb4b9ca..dce4f35db6 100644 --- a/src/concurrent/qtconcurrentfilter.h +++ b/src/concurrent/qtconcurrentfilter.h @@ -148,8 +148,8 @@ QFuture filteredReduced(Sequence &&sequence, #ifndef Q_CLANG_QDOC template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, @@ -163,8 +163,8 @@ QFuture filteredReduced(QThreadPool *pool, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture filteredReduced(Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, @@ -177,9 +177,9 @@ QFuture filteredReduced(Sequence &&sequence, } template >::ResultType, typename InitialValueType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> QFuture filteredReduced(QThreadPool *pool, Sequence &&sequence, @@ -196,9 +196,9 @@ QFuture filteredReduced(QThreadPool *pool, } template >::ResultType, typename InitialValueType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> QFuture filteredReduced(Sequence &&sequence, KeepFunctor &&keep, @@ -287,8 +287,7 @@ QFuture filteredReduced(Iterator begin, #ifndef Q_CLANG_QDOC template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, @@ -302,8 +301,7 @@ QFuture filteredReduced(QThreadPool *pool, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture filteredReduced(Iterator begin, Iterator end, KeepFunctor &&keep, @@ -317,8 +315,7 @@ QFuture filteredReduced(Iterator begin, } template >::ResultType, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> QFuture filteredReduced(QThreadPool *pool, @@ -336,8 +333,8 @@ QFuture filteredReduced(QThreadPool *pool, } template >::ResultType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> QFuture filteredReduced(Iterator begin, @@ -480,8 +477,8 @@ ResultType blockingFilteredReduced(Sequence &&sequence, #ifndef Q_CLANG_QDOC template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&keep, @@ -496,8 +493,8 @@ ResultType blockingFilteredReduced(QThreadPool *pool, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&keep, ReduceFunctor &&reduce, @@ -511,9 +508,9 @@ ResultType blockingFilteredReduced(Sequence &&sequence, } template >::ResultType, typename InitialValueType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> ResultType blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, @@ -531,9 +528,9 @@ ResultType blockingFilteredReduced(QThreadPool *pool, } template >::ResultType, typename InitialValueType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> ResultType blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&keep, @@ -627,8 +624,7 @@ ResultType blockingFilteredReduced(Iterator begin, #ifndef Q_CLANG_QDOC template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, @@ -644,8 +640,7 @@ ResultType blockingFilteredReduced(QThreadPool *pool, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&keep, @@ -660,8 +655,7 @@ ResultType blockingFilteredReduced(Iterator begin, } template >::ResultType, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> ResultType blockingFilteredReduced(QThreadPool *pool, @@ -679,8 +673,8 @@ ResultType blockingFilteredReduced(QThreadPool *pool, } template >::ResultType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> ResultType blockingFilteredReduced(Iterator begin, diff --git a/src/concurrent/qtconcurrentfunctionwrappers.h b/src/concurrent/qtconcurrentfunctionwrappers.h index 194d020fb2..59d2d61af6 100644 --- a/src/concurrent/qtconcurrentfunctionwrappers.h +++ b/src/concurrent/qtconcurrentfunctionwrappers.h @@ -41,6 +41,7 @@ #define QTCONCURRENT_FUNCTIONWRAPPERS_H #include +#include #include #include @@ -143,6 +144,50 @@ struct ReduceResultType }; #endif +template +struct hasCallOperator : std::false_type +{ +}; + +template +struct hasCallOperator> : std::true_type +{ +}; + +template +struct isIterator : std::false_type +{ +}; + +template +struct isIterator::value_type>> : std::true_type +{ +}; + +template +using isInvocable = std::is_invocable::value_type>; + +template +struct ReduceResultTypeHelper +{ +}; + +template +struct ReduceResultTypeHelper>> + || std::is_member_function_pointer_v>>> +{ + using type = typename QtPrivate::ReduceResultType>::ResultType; +}; + +template +struct ReduceResultTypeHelper>> + && hasCallOperator>::value>> +{ + using type = std::decay_t::First>; +}; + // -- MapSequenceResultType template diff --git a/src/concurrent/qtconcurrentmap.h b/src/concurrent/qtconcurrentmap.h index 4043ecd8a2..44a6caea4c 100644 --- a/src/concurrent/qtconcurrentmap.h +++ b/src/concurrent/qtconcurrentmap.h @@ -151,8 +151,8 @@ QFuture mappedReduced(Sequence &&sequence, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, @@ -166,8 +166,8 @@ QFuture mappedReduced(QThreadPool *pool, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture mappedReduced(Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, @@ -183,10 +183,9 @@ QFuture mappedReduced(Sequence &&sequence, template #else -template >::ResultType, - typename InitialValueType, +template ::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> #endif QFuture mappedReduced(QThreadPool *pool, @@ -207,10 +206,9 @@ QFuture mappedReduced(QThreadPool *pool, template #else -template >::ResultType, - typename InitialValueType, +template ::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> #endif QFuture mappedReduced(Sequence &&sequence, @@ -299,8 +297,7 @@ QFuture mappedReduced(Iterator begin, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, @@ -315,7 +312,7 @@ QFuture mappedReduced(QThreadPool *pool, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> QFuture mappedReduced(Iterator begin, Iterator end, MapFunctor &&map, @@ -333,8 +330,7 @@ template #else template >::ResultType, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> #endif @@ -357,8 +353,8 @@ template #else template>::ResultType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> #endif @@ -528,8 +524,8 @@ ResultType blockingMappedReduced(Sequence &&sequence, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&map, @@ -545,8 +541,8 @@ ResultType blockingMappedReduced(QThreadPool *pool, } template >::ResultType> + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingMappedReduced(Sequence &&sequence, MapFunctor &&map, ReduceFunctor &&reduce, @@ -564,10 +560,9 @@ ResultType blockingMappedReduced(Sequence &&sequence, template #else -template >::ResultType, - typename InitialValueType, +template ::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> #endif ResultType blockingMappedReduced(QThreadPool *pool, @@ -589,10 +584,9 @@ ResultType blockingMappedReduced(QThreadPool *pool, template #else -template>::ResultType, - typename InitialValueType, +template::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, std::enable_if_t, int> = 0> #endif ResultType blockingMappedReduced(Sequence &&sequence, @@ -687,8 +681,7 @@ ResultType blockingMappedReduced(Iterator begin, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, @@ -704,8 +697,7 @@ ResultType blockingMappedReduced(QThreadPool *pool, } template >::ResultType> + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type> ResultType blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&map, @@ -724,8 +716,7 @@ template #else template >::ResultType, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> #endif @@ -749,8 +740,8 @@ template #else template >::ResultType, + std::enable_if_t::value, int> = 0, + typename ResultType = typename QtPrivate::ReduceResultTypeHelper::type, typename InitialValueType, std::enable_if_t, int> = 0> #endif diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp index 6c27884977..1a1ad6251a 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp +++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp @@ -410,23 +410,47 @@ void testFilteredReduced(const QList &sourceObjectList, FilterObject filterObject, ReduceObject reduceObject) { - const ResultObject result1 = QtConcurrent::filteredReduced( - sourceObjectList, filterObject, reduceObject).result(); - QCOMPARE(result1, expectedResult); - - const ResultObject result2 = QtConcurrent::filteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject).result(); - QCOMPARE(result2, expectedResult); - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced( - sourceObjectList, filterObject, reduceObject); - QCOMPARE(result3, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced( + sourceObjectList, filterObject, reduceObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced( + sourceObjectList, filterObject, reduceObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject); + QCOMPARE(result4, expectedResult); + } - const ResultObject result4 = QtConcurrent::blockingFilteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject); - QCOMPARE(result4, expectedResult); + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::filteredReduced( + sourceObjectList, filterObject, reduceObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced( + sourceObjectList, filterObject, reduceObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject); + QCOMPARE(result4, expectedResult); + } } template ( - pool, sourceObjectList, filterObject, reduceObject).result(); - 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).result(); - QCOMPARE(result2, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced( - pool, sourceObjectList, filterObject, reduceObject); - QCOMPARE(result3, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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 + } - 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 + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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() @@ -666,50 +719,50 @@ void tst_QtConcurrentFilter::filteredReducedWithMoveOnlyCallables() const auto sum = 6; { const auto result = - QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly()).result(); + QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::filteredReduced(intList.begin(), intList.end(), - KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly()).result(); + QtConcurrent::filteredReduced(intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingFilteredReduced( + intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingFilteredReduced( + intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); QCOMPARE(result, sum); } QThreadPool pool; { const auto result = - QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly()).result(); + QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::filteredReduced( - &pool, intList.begin(), intList.end(), - KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()).result(); + const auto result = QtConcurrent::filteredReduced( + &pool, intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingFilteredReduced( + &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingFilteredReduced( + &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()); QCOMPARE(result, sum); } } @@ -774,23 +827,47 @@ void testFilteredReducedInitialValue(const QList &sourceObjectList ReduceObject reduceObject, InitialObject &&initialObject) { - const ResultObject result1 = QtConcurrent::filteredReduced( - sourceObjectList, filterObject, reduceObject, initialObject).result(); - QCOMPARE(result1, expectedResult); - - const ResultObject result2 = QtConcurrent::filteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject, initialObject).result(); - QCOMPARE(result2, expectedResult); - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced( - sourceObjectList, filterObject, reduceObject, initialObject); - QCOMPARE(result3, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced( + sourceObjectList, filterObject, reduceObject, initialObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced( + sourceObjectList, filterObject, reduceObject, initialObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject); + QCOMPARE(result4, expectedResult); + } - const ResultObject result4 = QtConcurrent::blockingFilteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject, initialObject); - QCOMPARE(result4, expectedResult); + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::filteredReduced( + sourceObjectList, filterObject, reduceObject, initialObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced( + sourceObjectList, filterObject, reduceObject, initialObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject); + QCOMPARE(result4, expectedResult); + } } template ( - pool, sourceObjectList, filterObject, reduceObject, initialObject).result(); - 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).result(); - QCOMPARE(result2, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced( - pool, sourceObjectList, filterObject, reduceObject, initialObject); - QCOMPARE(result3, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject, initialObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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 + } - 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 + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::filteredReduced( + pool, sourceObjectList, filterObject, reduceObject, initialObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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() @@ -1053,52 +1159,52 @@ void tst_QtConcurrentFilter::filteredReducedInitialValueWithMoveOnlyCallables() const auto sum = 16; { const auto result = - QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly(), initial).result(); + QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::filteredReduced(intList.begin(), intList.end(), - KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly(), initial).result(); + QtConcurrent::filteredReduced(intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial); + const auto result = QtConcurrent::blockingFilteredReduced( + intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), - initial); + const auto result = QtConcurrent::blockingFilteredReduced( + intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), + initial); QCOMPARE(result, sum); } QThreadPool pool; { const auto result = - QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly(), initial).result(); + QtConcurrent::filteredReduced(&pool, intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::filteredReduced( + QtConcurrent::filteredReduced( &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial); + const auto result = QtConcurrent::blockingFilteredReduced( + &pool, intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingFilteredReduced( - &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), - IntSumReduceMoveOnly(), initial); + const auto result = QtConcurrent::blockingFilteredReduced( + &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial); QCOMPARE(result, sum); } } diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp index 5bcf90c0d6..93cf1bf99e 100644 --- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp +++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp @@ -761,22 +761,45 @@ public: template void testMappedReduced(const QList &sourceObjectList, const ResultObject &expectedResult, MapObject mapObject, ReduceObject reduceObject) { - const ResultObject result1 = QtConcurrent::mappedReduced( - sourceObjectList, mapObject, reduceObject).result(); - QCOMPARE(result1, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::mappedReduced( + sourceObjectList, mapObject, reduceObject).result(); + QCOMPARE(result1, expectedResult); - const ResultObject result2 = QtConcurrent::mappedReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - mapObject, reduceObject).result(); - QCOMPARE(result2, expectedResult); + const ResultObject result2 = QtConcurrent::mappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject).result(); + QCOMPARE(result2, expectedResult); - const ResultObject result3 = QtConcurrent::blockingMappedReduced( - sourceObjectList, mapObject, reduceObject); - QCOMPARE(result3, expectedResult); + const ResultObject result3 = QtConcurrent::blockingMappedReduced( + sourceObjectList, mapObject, reduceObject); + QCOMPARE(result3, expectedResult); - const ResultObject result4 = QtConcurrent::blockingMappedReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject); - QCOMPARE(result4, expectedResult); + const ResultObject result4 = QtConcurrent::blockingMappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject); + QCOMPARE(result4, expectedResult); + } + + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::mappedReduced( + sourceObjectList, mapObject, reduceObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::mappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingMappedReduced( + sourceObjectList, mapObject, reduceObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingMappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject); + QCOMPARE(result4, expectedResult); + } } template @@ -886,27 +909,57 @@ void testMappedReducedThreadPool(QThreadPool *pool, MapObject mapObject, ReduceObject reduceObject) { - const ResultObject result1 = QtConcurrent::mappedReduced( - pool, sourceObjectList, mapObject, reduceObject).result(); - QCOMPARE(result1, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::mappedReduced( + pool, sourceObjectList, mapObject, reduceObject).result(); + 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).result(); - QCOMPARE(result2, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + const ResultObject result2 = + QtConcurrent::mappedReduced(pool, sourceObjectList.constBegin(), + sourceObjectList.constEnd(), mapObject, + reduceObject).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working - const ResultObject result3 = QtConcurrent::blockingMappedReduced(pool, - sourceObjectList, mapObject, reduceObject); - QCOMPARE(result3, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + 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 + 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 + } + + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::mappedReduced( + pool, sourceObjectList, mapObject, reduceObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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) @@ -994,46 +1047,46 @@ void tst_QtConcurrentMap::mappedReducedWithMoveOnlyCallable() const QList intList { 1, 2, 3 }; const auto sum = 12; { - const auto result = QtConcurrent::mappedReduced( + const auto result = QtConcurrent::mappedReduced( intList, MultiplyBy2(), IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::mappedReduced(intList.begin(), intList.end(), - MultiplyBy2(), IntSumReduceMoveOnly()).result(); + QtConcurrent::mappedReduced(intList.begin(), intList.end(), + MultiplyBy2(), IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced(intList, MultiplyBy2(), - IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingMappedReduced(intList, MultiplyBy2(), + IntSumReduceMoveOnly()); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( + const auto result = QtConcurrent::blockingMappedReduced( intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly()); QCOMPARE(result, sum); } QThreadPool pool; { - const auto result = QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(), - IntSumReduceMoveOnly()).result(); + const auto result = QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(), + IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(), - MultiplyBy2(), IntSumReduceMoveOnly()).result(); + QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(), + MultiplyBy2(), IntSumReduceMoveOnly()).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced(&pool, intList, MultiplyBy2(), - IntSumReduceMoveOnly()); + const auto result = QtConcurrent::blockingMappedReduced(&pool, intList, MultiplyBy2(), + IntSumReduceMoveOnly()); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( + const auto result = QtConcurrent::blockingMappedReduced( &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly()); QCOMPARE(result, sum); } @@ -1096,23 +1149,49 @@ void testMappedReducedInitialValue(const QList &sourceObjectList, ReduceObject reduceObject, InitialObject &&initialObject) { - const ResultObject result1 = - QtConcurrent::mappedReduced(sourceObjectList, mapObject, reduceObject, - initialObject).result(); - QCOMPARE(result1, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = + QtConcurrent::mappedReduced(sourceObjectList, mapObject, reduceObject, + initialObject).result(); + QCOMPARE(result1, expectedResult); - const ResultObject result2 = QtConcurrent::mappedReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - mapObject, reduceObject, initialObject).result(); - QCOMPARE(result2, expectedResult); + const ResultObject result2 = QtConcurrent::mappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); - const ResultObject result3 = QtConcurrent::blockingMappedReduced( - sourceObjectList, mapObject, reduceObject, initialObject); - QCOMPARE(result3, expectedResult); + const ResultObject result3 = QtConcurrent::blockingMappedReduced( + sourceObjectList, mapObject, reduceObject, initialObject); + QCOMPARE(result3, expectedResult); - const ResultObject result4 = QtConcurrent::blockingMappedReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), mapObject, reduceObject, initialObject); - QCOMPARE(result4, expectedResult); + const ResultObject result4 = QtConcurrent::blockingMappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject, initialObject); + QCOMPARE(result4, expectedResult); + } + + // Result type is deduced + { + const ResultObject result1 = + QtConcurrent::mappedReduced(sourceObjectList, mapObject, reduceObject, + initialObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::mappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingMappedReduced( + sourceObjectList, mapObject, reduceObject, initialObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingMappedReduced( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + mapObject, reduceObject, initialObject); + QCOMPARE(result4, expectedResult); + } } template @@ -1234,28 +1313,57 @@ void testMappedReducedInitialValueThreadPool(QThreadPool *pool, ReduceObject reduceObject, InitialObject &&initialObject) { - const ResultObject result1 = QtConcurrent::mappedReduced( - pool, sourceObjectList, mapObject, reduceObject, initialObject).result(); - QCOMPARE(result1, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::mappedReduced( + pool, sourceObjectList, mapObject, reduceObject, initialObject).result(); + 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).result(); - QCOMPARE(result2, expectedResult); - QCOMPARE(threadCount(), 1); // ensure the only one thread was working + const ResultObject result2 = + QtConcurrent::mappedReduced(pool, sourceObjectList.constBegin(), + sourceObjectList.constEnd(), mapObject, + reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working - 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 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 + 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 + } + + // Result type is deduced + { + const ResultObject result1 = QtConcurrent::mappedReduced( + pool, sourceObjectList, mapObject, reduceObject, initialObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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() @@ -1341,50 +1449,50 @@ void tst_QtConcurrentMap::mappedReducedInitialValueWithMoveOnlyCallable() const auto sum = 22; { const auto result = - QtConcurrent::mappedReduced(intList, MultiplyBy2(), - IntSumReduceMoveOnly(), initialValue).result(); + QtConcurrent::mappedReduced(intList, MultiplyBy2(), + IntSumReduceMoveOnly(), initialValue).result(); QCOMPARE(result, sum); } { const auto result = - QtConcurrent::mappedReduced(intList.begin(), intList.end(), MultiplyBy2(), - IntSumReduceMoveOnly(), initialValue).result(); + QtConcurrent::mappedReduced(intList.begin(), intList.end(), MultiplyBy2(), + IntSumReduceMoveOnly(), initialValue).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( - intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue); + const auto result = QtConcurrent::blockingMappedReduced( + intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( - intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(), - initialValue); + const auto result = QtConcurrent::blockingMappedReduced( + intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(), + initialValue); QCOMPARE(result, sum); } QThreadPool pool; { const auto result = - QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(), - IntSumReduceMoveOnly(), initialValue).result(); + QtConcurrent::mappedReduced(&pool, intList, MultiplyBy2(), + IntSumReduceMoveOnly(), initialValue).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(), - MultiplyBy2(), IntSumReduceMoveOnly(), - initialValue).result(); + const auto result = QtConcurrent::mappedReduced(&pool, intList.begin(), intList.end(), + MultiplyBy2(), IntSumReduceMoveOnly(), + initialValue).result(); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( - &pool, intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue); + const auto result = QtConcurrent::blockingMappedReduced( + &pool, intList, MultiplyBy2(), IntSumReduceMoveOnly(), initialValue); QCOMPARE(result, sum); } { - const auto result = QtConcurrent::blockingMappedReduced( - &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(), - initialValue); + const auto result = QtConcurrent::blockingMappedReduced( + &pool, intList.begin(), intList.end(), MultiplyBy2(), IntSumReduceMoveOnly(), + initialValue); QCOMPARE(result, sum); } } -- cgit v1.2.3