diff options
Diffstat (limited to 'tests/auto/concurrent/qtconcurrentfilter')
4 files changed, 693 insertions, 133 deletions
diff --git a/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt b/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt deleted file mode 100644 index be8c936c48..0000000000 --- a/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt +++ /dev/null @@ -1,12 +0,0 @@ -# Generated from qtconcurrentfilter.pro. - -##################################################################### -## tst_qtconcurrentfilter Test: -##################################################################### - -add_qt_test(tst_qtconcurrentfilter - SOURCES - tst_qtconcurrentfilter.cpp - PUBLIC_LIBRARIES - Qt::Concurrent -) diff --git a/tests/auto/concurrent/qtconcurrentfilter/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentfilter/CMakeLists.txt index 7868906178..3c00393d39 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/CMakeLists.txt +++ b/tests/auto/concurrent/qtconcurrentfilter/CMakeLists.txt @@ -1,12 +1,19 @@ -# Generated from qtconcurrentfilter.pro. +# Copyright (C) 2022 The Qt Company Ltd. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qtconcurrentfilter Test: ##################################################################### -qt_add_test(tst_qtconcurrentfilter +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qtconcurrentfilter LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + +qt_internal_add_test(tst_qtconcurrentfilter SOURCES tst_qtconcurrentfilter.cpp - PUBLIC_LIBRARIES + LIBRARIES Qt::Concurrent ) diff --git a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro b/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro deleted file mode 100644 index f2e3e0c8e1..0000000000 --- a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro +++ /dev/null @@ -1,4 +0,0 @@ -CONFIG += testcase -TARGET = tst_qtconcurrentfilter -QT = core testlib concurrent -SOURCES = tst_qtconcurrentfilter.cpp diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp index 945f286c9d..e19a596d5d 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp +++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp @@ -1,36 +1,12 @@ -/**************************************************************************** -** -** Copyright (C) 2016 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the test suite of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:GPL-EXCEPT$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 3 as published by the Free Software -** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// Copyright (C) 2016 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <qtconcurrentfilter.h> #include <QCoreApplication> #include <QList> -#include <QtTest/QtTest> +#include <QTest> +#include <QSet> -#include "../qtconcurrentmap/functions.h" +#include "../testhelper_functions.h" class tst_QtConcurrentFilter : public QObject { @@ -39,14 +15,19 @@ class tst_QtConcurrentFilter : public QObject private slots: void filter(); void filterThreadPool(); + void filterWithMoveOnlyCallable(); void filtered(); void filteredThreadPool(); + void filteredWithMoveOnlyCallable(); void filteredReduced(); void filteredReducedThreadPool(); + void filteredReducedWithMoveOnlyCallables(); void filteredReducedDifferentType(); void filteredReducedInitialValue(); void filteredReducedInitialValueThreadPool(); + void filteredReducedInitialValueWithMoveOnlyCallables(); void filteredReducedDifferentTypeInitialValue(); + void filteredReduceOptionConvertableToResultType(); void resultAt(); void incrementalResults(); void noDetach(); @@ -98,6 +79,19 @@ void tst_QtConcurrentFilter::filter() CHECK_FAIL("member"); testFilter(intList, intListEven, lambdaIsEven); CHECK_FAIL("lambda"); + + // non-template sequences + { + + NonTemplateSequence list({ 1, 2, 3, 4 }); + QtConcurrent::filter(list, keepEvenNumbers).waitForFinished(); + QCOMPARE(list, NonTemplateSequence({ 2, 4 })); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + QtConcurrent::blockingFilter(list, keepEvenNumbers); + QCOMPARE(list, NonTemplateSequence({ 2, 4 })); + } } static QSemaphore semaphore(1); @@ -175,6 +169,47 @@ void tst_QtConcurrentFilter::filterThreadPool() CHECK_FAIL("function"); testFilterThreadPool(&pool, intList, intListEven, lambdaIsOdd); CHECK_FAIL("lambda"); + + // non-template sequences + { + + NonTemplateSequence list({ 1, 2, 3, 4 }); + QtConcurrent::filter(list, keepEvenIntegers).waitForFinished(); + QCOMPARE(list, NonTemplateSequence({ 2, 4 })); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + QtConcurrent::blockingFilter(list, keepEvenIntegers); + QCOMPARE(list, NonTemplateSequence({ 2, 4 })); + } +} + +void tst_QtConcurrentFilter::filterWithMoveOnlyCallable() +{ + const QList<int> intListEven { 2, 4 }; + { + QList<int> intList { 1, 2, 3, 4 }; + QtConcurrent::filter(intList, KeepEvenIntegersMoveOnly()).waitForFinished(); + QCOMPARE(intList, intListEven); + } + + { + QList<int> intList { 1, 2, 3, 4 }; + QtConcurrent::blockingFilter(intList, KeepEvenIntegersMoveOnly()); + QCOMPARE(intList, intListEven); + } + + QThreadPool pool; + { + QList<int> intList { 1, 2, 3, 4 }; + QtConcurrent::filter(&pool, intList, KeepEvenIntegersMoveOnly()).waitForFinished(); + QCOMPARE(intList, intListEven); + } + { + QList<int> intList { 1, 2, 3, 4 }; + QtConcurrent::blockingFilter(&pool, intList, KeepEvenIntegersMoveOnly()); + QCOMPARE(intList, intListEven); + } } template <typename SourceObject, @@ -221,6 +256,40 @@ void tst_QtConcurrentFilter::filtered() CHECK_FAIL("member"); testFiltered(intList, intListEven, lambdaIsEven); CHECK_FAIL("lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = QtConcurrent::filtered(list, keepEvenIntegers); + QCOMPARE(future.results(), QList({ 2, 4 })); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = QtConcurrent::blockingFiltered(list, keepEvenIntegers); + QCOMPARE(result, NonTemplateSequence({ 2, 4 })); + } + + { + // rvalue sequences + auto future = QtConcurrent::filtered(std::vector { 1, 2, 3, 4 }, keepEvenIntegers); + QCOMPARE(future.results(), QList<int>({ 2, 4 })); + + auto result = QtConcurrent::blockingFiltered(std::vector { 1, 2, 3, 4 }, keepEvenIntegers); + QCOMPARE(result, std::vector<int>({ 2, 4 })); + } + + { + // move only types sequences + auto future = QtConcurrent::filtered(MoveOnlyVector<int>({ 1, 2, 3, 4 }), keepEvenIntegers); + QCOMPARE(future.results(), QList<int>({ 2, 4 })); + +#if 0 + // does not work yet + auto result = QtConcurrent::blockingFiltered( + MoveOnlyVector<int>({ 1, 2, 3, 4 }), keepEvenIntegers); + QCOMPARE(result, std::vector<int>({ 2, 4 })); +#endif + } } template <typename SourceObject, @@ -274,6 +343,89 @@ void tst_QtConcurrentFilter::filteredThreadPool() CHECK_FAIL("function"); testFilteredThreadPool(&pool, intList, intListEven, lambdaIsOdd); CHECK_FAIL("lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = QtConcurrent::filtered(&pool, list, keepEvenIntegers); + QCOMPARE(future.results(), QList({ 2, 4 })); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = QtConcurrent::blockingFiltered(&pool, list, keepEvenIntegers); + QCOMPARE(result, NonTemplateSequence({ 2, 4 })); + } + + { + // rvalue sequences + auto future = QtConcurrent::filtered(&pool, std::vector { 1, 2, 3, 4 }, keepEvenIntegers); + QCOMPARE(future.results(), QList<int>({ 2, 4 })); + + auto result = + QtConcurrent::blockingFiltered(&pool, std::vector { 1, 2, 3, 4 }, keepEvenIntegers); + QCOMPARE(result, std::vector<int>({ 2, 4 })); + } + + { + // move-only sequences + auto future = QtConcurrent::filtered(&pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepEvenIntegers); + QCOMPARE(future.results(), QList<int>({ 2, 4 })); + +#if 0 + // does not work yet + auto result = + QtConcurrent::blockingFiltered( + &pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), keepEvenIntegers); + QCOMPARE(result, std::vector<int>({ 2, 4 })); +#endif + } +} + +void tst_QtConcurrentFilter::filteredWithMoveOnlyCallable() +{ + const QList<int> intList { 1, 2, 3, 4 }; + const QList<int> intListEven { 2, 4 }; + { + const auto result = QtConcurrent::filtered(intList, KeepEvenIntegersMoveOnly()).results(); + QCOMPARE(result, intListEven); + } + { + const auto result = QtConcurrent::filtered( + intList.begin(), intList.end(), KeepEvenIntegersMoveOnly()).results(); + QCOMPARE(result, intListEven); + } + { + const auto result = QtConcurrent::blockingFiltered(intList, KeepEvenIntegersMoveOnly()); + QCOMPARE(result, intListEven); + } + { + const auto result = QtConcurrent::blockingFiltered<QList<int>>( + intList.begin(), intList.end(), KeepEvenIntegersMoveOnly()); + QCOMPARE(result, intListEven); + } + + QThreadPool pool; + { + const auto result = + QtConcurrent::filtered(&pool, intList, KeepEvenIntegersMoveOnly()).results(); + QCOMPARE(result, intListEven); + } + { + const auto result = QtConcurrent::filtered(&pool, intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly()).results(); + QCOMPARE(result, intListEven); + } + { + const auto result = + QtConcurrent::blockingFiltered(&pool, intList, KeepEvenIntegersMoveOnly()); + QCOMPARE(result, intListEven); + } + { + const auto result = QtConcurrent::blockingFiltered<QList<int>>( + &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly()); + QCOMPARE(result, intListEven); + } } template <typename SourceObject, @@ -285,23 +437,47 @@ void testFilteredReduced(const QList<SourceObject> &sourceObjectList, FilterObject filterObject, ReduceObject reduceObject) { - const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>( - sourceObjectList, filterObject, reduceObject); - QCOMPARE(result1, expectedResult); - - const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject); - QCOMPARE(result2, expectedResult); - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( - sourceObjectList, filterObject, reduceObject); - QCOMPARE(result3, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>( + sourceObjectList, filterObject, reduceObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( + sourceObjectList, filterObject, reduceObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject); + QCOMPARE(result4, expectedResult); + } - const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>( - 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 <typename SourceObject, @@ -315,12 +491,13 @@ void testFilteredReduced(const QList<SourceObject> &sourceObjectList, QtConcurrent::ReduceOptions options) { const ResultObject result1 = QtConcurrent::filteredReduced( - sourceObjectList, filterObject, reduceObject, options); + sourceObjectList, filterObject, reduceObject, options).result(); QCOMPARE(result1, expectedResult); - const ResultObject result2 = QtConcurrent::filteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), filterObject, - reduceObject, options); + const ResultObject result2 = + QtConcurrent::filteredReduced(sourceObjectList.constBegin(), + sourceObjectList.constEnd(), + filterObject, reduceObject, options).result(); QCOMPARE(result2, expectedResult); const ResultObject result3 = QtConcurrent::blockingFilteredReduced( @@ -356,8 +533,9 @@ void tst_QtConcurrentFilter::filteredReduced() const int intSum = 6; // sum of even values const Number numberSum = 6; // sum of even values - void (QList<int>::*pushBackInt)(const int &) = &QList<int>::push_back; - void (QList<Number>::*pushBackNumber)(const Number &) = &QList<Number>::push_back; + void (QList<int>::*pushBackInt)(QList<int>::parameter_type) = &QList<int>::push_back; + void (QList<Number>::*pushBackNumber)(QList<Number>::parameter_type) = + &QList<Number>::push_back; auto lambdaIsEven = [](const int &x) { return (x & 1) == 0; @@ -409,6 +587,40 @@ void tst_QtConcurrentFilter::filteredReduced() CHECK_FAIL("lambda-member"); testFilteredReduced(intList, intSum, lambdaIsEven, lambdaIntSumReduce); CHECK_FAIL("lambda-lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce); + QCOMPARE(future.result(), intSum); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce); + QCOMPARE(result, intSum); + } + + { + // rvalue sequences + auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers, + intSumReduce); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced(std::vector { 1, 2, 3, 4 }, + keepEvenIntegers, intSumReduce); + QCOMPARE(result, intSum); + } + + { + // move only sequences + auto future = QtConcurrent::filteredReduced(MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepEvenIntegers, intSumReduce); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced(MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepEvenIntegers, intSumReduce); + QCOMPARE(result, intSum); + } } template <typename SourceObject, @@ -421,27 +633,57 @@ void testFilteredReducedThreadPool(QThreadPool *pool, 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 - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( - 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<ResultObject>( + pool, sourceObjectList, filterObject, reduceObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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 + } - 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 + // 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() @@ -485,6 +727,96 @@ void tst_QtConcurrentFilter::filteredReducedThreadPool() CHECK_FAIL("lambda-function"); testFilteredReducedThreadPool(&pool, intList, intSum, lambdaIsOdd, lambdaSumReduce); CHECK_FAIL("lambda-lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = QtConcurrent::filteredReduced(&pool, list, keepOddIntegers, intSumReduce); + QCOMPARE(future.result(), intSum); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = + QtConcurrent::blockingFilteredReduced(&pool, list, keepOddIntegers, intSumReduce); + QCOMPARE(result, intSum); + } + + { + // rvalue sequences + auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 }, + keepOddIntegers, intSumReduce); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced(&pool, std::vector { 1, 2, 3, 4 }, + keepOddIntegers, intSumReduce); + QCOMPARE(result, intSum); + } + + { + // move only sequences + auto future = QtConcurrent::filteredReduced(&pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepOddIntegers, intSumReduce); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced( + &pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), keepOddIntegers, intSumReduce); + QCOMPARE(result, intSum); + } +} + +void tst_QtConcurrentFilter::filteredReducedWithMoveOnlyCallables() +{ + const QList<int> intList { 1, 2, 3, 4 }; + const QList<int> intListEven { 2, 4 }; + const auto sum = 6; + { + const auto result = + QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()).result(); + QCOMPARE(result, sum); + } + { + const auto result = + QtConcurrent::filteredReduced(intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()).result(); + QCOMPARE(result, sum); + } + { + const auto result = QtConcurrent::blockingFilteredReduced( + intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly()); + QCOMPARE(result, sum); + } + { + 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(); + QCOMPARE(result, sum); + } + { + 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()); + QCOMPARE(result, sum); + } + { + const auto result = QtConcurrent::blockingFilteredReduced( + &pool, intList.begin(), intList.end(), KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly()); + QCOMPARE(result, sum); + } } void tst_QtConcurrentFilter::filteredReducedDifferentType() @@ -547,23 +879,47 @@ void testFilteredReducedInitialValue(const QList<SourceObject> &sourceObjectList ReduceObject reduceObject, InitialObject &&initialObject) { - const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>( - sourceObjectList, filterObject, reduceObject, initialObject); - QCOMPARE(result1, expectedResult); - - const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject, initialObject); - QCOMPARE(result2, expectedResult); - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( - sourceObjectList, filterObject, reduceObject, initialObject); - QCOMPARE(result3, expectedResult); + // Result type is passed explicitly + { + const ResultObject result1 = QtConcurrent::filteredReduced<ResultObject>( + sourceObjectList, filterObject, reduceObject, initialObject).result(); + QCOMPARE(result1, expectedResult); + + const ResultObject result2 = QtConcurrent::filteredReduced<ResultObject>( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject).result(); + QCOMPARE(result2, expectedResult); + + const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( + sourceObjectList, filterObject, reduceObject, initialObject); + QCOMPARE(result3, expectedResult); + + const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>( + sourceObjectList.constBegin(), sourceObjectList.constEnd(), + filterObject, reduceObject, initialObject); + QCOMPARE(result4, expectedResult); + } - const ResultObject result4 = QtConcurrent::blockingFilteredReduced<ResultObject>( - 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 <typename SourceObject, @@ -579,12 +935,13 @@ void testFilteredReducedInitialValue(const QList<SourceObject> &sourceObjectList QtConcurrent::ReduceOptions options) { const ResultObject result1 = QtConcurrent::filteredReduced( - sourceObjectList, filterObject, reduceObject, initialObject, options); + sourceObjectList, filterObject, reduceObject, initialObject, options).result(); QCOMPARE(result1, expectedResult); - const ResultObject result2 = QtConcurrent::filteredReduced( - sourceObjectList.constBegin(), sourceObjectList.constEnd(), - filterObject, reduceObject, initialObject, options); + const ResultObject result2 = + QtConcurrent::filteredReduced(sourceObjectList.constBegin(), + sourceObjectList.constEnd(), filterObject, reduceObject, + initialObject, options).result(); QCOMPARE(result2, expectedResult); const ResultObject result3 = QtConcurrent::blockingFilteredReduced( @@ -612,8 +969,9 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue() const int intSum = 16; // sum of even values and initial value const Number numberSum = 16; // sum of even values and initial value - void (QList<int>::*pushBackInt)(const int &) = &QList<int>::push_back; - void (QList<Number>::*pushBackNumber)(const Number &) = &QList<Number>::push_back; + void (QList<int>::*pushBackInt)(QList<int>::parameter_type) = &QList<int>::push_back; + void (QList<Number>::*pushBackNumber)(QList<Number>::parameter_type) = + &QList<Number>::push_back; auto lambdaIsEven = [](const int &x) { return (x & 1) == 0; @@ -680,6 +1038,42 @@ void tst_QtConcurrentFilter::filteredReducedInitialValue() testFilteredReducedInitialValue(intList, intSum, lambdaIsEven, lambdaIntSumReduce, intInitial); CHECK_FAIL("lambda-lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = + QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce, + intInitial); + QCOMPARE(result, intSum); + } + + { + // rvalue sequences + auto future = QtConcurrent::filteredReduced(std::vector { 1, 2, 3, 4 }, keepEvenIntegers, + intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced( + std::vector { 1, 2, 3, 4 }, keepEvenIntegers, intSumReduce, intInitial); + QCOMPARE(result, intSum); + } + + { + // move only sequences + auto future = QtConcurrent::filteredReduced(MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepEvenIntegers, intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced( + MoveOnlyVector<int>({ 1, 2, 3, 4 }), keepEvenIntegers, intSumReduce, intInitial); + QCOMPARE(result, intSum); + } } template <typename SourceObject, @@ -694,27 +1088,57 @@ void testFilteredReducedInitialValueThreadPool(QThreadPool *pool, 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 - - const ResultObject result3 = QtConcurrent::blockingFilteredReduced<ResultObject>( - 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<ResultObject>( + pool, sourceObjectList, filterObject, reduceObject, initialObject).result(); + 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).result(); + QCOMPARE(result2, expectedResult); + QCOMPARE(threadCount(), 1); // ensure the only one thread was working + + 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 + } - 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 + // 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() @@ -768,6 +1192,101 @@ void tst_QtConcurrentFilter::filteredReducedInitialValueThreadPool() testFilteredReducedInitialValueThreadPool(&pool, intList, intSum, lambdaIsOdd, lambdaSumReduce, intInitial); CHECK_FAIL("lambda-lambda"); + + // non-template sequences + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto future = + QtConcurrent::filteredReduced(list, keepOddIntegers, intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + } + { + NonTemplateSequence list({ 1, 2, 3, 4 }); + auto result = QtConcurrent::blockingFilteredReduced(list, keepOddIntegers, intSumReduce, + intInitial); + QCOMPARE(result, intSum); + } + + { + // rvalue sequences + auto future = QtConcurrent::filteredReduced(&pool, std::vector { 1, 2, 3, 4 }, + keepOddIntegers, intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + + auto result = QtConcurrent::blockingFilteredReduced( + &pool, std::vector { 1, 2, 3, 4 }, keepOddIntegers, intSumReduce, intInitial); + QCOMPARE(result, intSum); + } + + { + // move only sequences + auto future = QtConcurrent::filteredReduced(&pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepOddIntegers, intSumReduce, intInitial); + QCOMPARE(future.result(), intSum); + + auto result = + QtConcurrent::blockingFilteredReduced(&pool, MoveOnlyVector<int>({ 1, 2, 3, 4 }), + keepOddIntegers, intSumReduce, intInitial); + QCOMPARE(result, intSum); + } +} + +void tst_QtConcurrentFilter::filteredReducedInitialValueWithMoveOnlyCallables() +{ + const QList<int> intList { 1, 2, 3, 4 }; + const QList<int> intListEven { 2, 4 }; + const auto initial = 10; + const auto sum = 16; + { + const auto result = + QtConcurrent::filteredReduced(intList, KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial).result(); + QCOMPARE(result, sum); + } + { + const auto result = + QtConcurrent::filteredReduced(intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), + IntSumReduceMoveOnly(), initial).result(); + QCOMPARE(result, sum); + } + { + const auto result = QtConcurrent::blockingFilteredReduced( + intList, KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial); + QCOMPARE(result, sum); + } + { + 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(); + QCOMPARE(result, sum); + } + { + const auto result = + QtConcurrent::filteredReduced( + &pool, intList.begin(), intList.end(), + KeepEvenIntegersMoveOnly(), IntSumReduceMoveOnly(), initial).result(); + QCOMPARE(result, sum); + } + { + 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); + QCOMPARE(result, sum); + } } void tst_QtConcurrentFilter::filteredReducedDifferentTypeInitialValue() @@ -820,6 +1339,56 @@ void tst_QtConcurrentFilter::filteredReducedDifferentTypeInitialValue() CHECK_FAIL("lambda-lambda"); } +void tst_QtConcurrentFilter::filteredReduceOptionConvertableToResultType() +{ + const QList<int> intList { 1, 2, 3 }; + const int sum = 4; + QThreadPool p; + ReduceOption ro = OrderedReduce; + + // With container + QCOMPARE(QtConcurrent::filteredReduced(intList, keepOddIntegers, intSumReduce, ro).result(), + sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced(intList, keepOddIntegers, intSumReduce, ro), + sum); + + // With iterators + QCOMPARE(QtConcurrent::filteredReduced(intList.begin(), intList.end(), keepOddIntegers, + intSumReduce, ro).result(), sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced(intList.begin(), intList.end(), keepOddIntegers, + intSumReduce, ro), sum); + + // With custom QThreadPool; + QCOMPARE(QtConcurrent::filteredReduced(&p, intList, keepOddIntegers, intSumReduce, ro).result(), + sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced(&p, intList, keepOddIntegers, intSumReduce, ro), + sum); + QCOMPARE(QtConcurrent::filteredReduced(&p, intList.begin(), intList.end(), keepOddIntegers, + intSumReduce, ro).result(), sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced(&p, intList.begin(), intList.end(), + keepOddIntegers, intSumReduce, ro), sum); + + // The same as above, but specify the result type explicitly (this invokes different overloads) + QCOMPARE(QtConcurrent::filteredReduced<int>(intList, keepOddIntegers, intSumReduce, + ro).result(), sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced<int>(intList, keepOddIntegers, intSumReduce, ro), + sum); + + QCOMPARE(QtConcurrent::filteredReduced<int>(intList.begin(), intList.end(), keepOddIntegers, + intSumReduce, ro).result(), sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced<int>(intList.begin(), intList.end(), + keepOddIntegers, intSumReduce, ro), sum); + + QCOMPARE(QtConcurrent::filteredReduced<int>(&p, intList, keepOddIntegers, intSumReduce, + ro).result(), sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced<int>(&p, intList, keepOddIntegers, intSumReduce, + ro), sum); + QCOMPARE(QtConcurrent::filteredReduced<int>(&p, intList.begin(), intList.end(), keepOddIntegers, + intSumReduce, ro).result(),sum); + QCOMPARE(QtConcurrent::blockingFilteredReduced<int>(&p, intList.begin(), intList.end(), + keepOddIntegers, intSumReduce, ro), sum); +} + bool filterfn(int i) { return (i % 2); @@ -865,7 +1434,7 @@ void tst_QtConcurrentFilter::incrementalResults() QCOMPARE(future.isFinished(), true); QCOMPARE(future.resultCount(), count / 2); - QCOMPARE(future.results().count(), count / 2); + QCOMPARE(future.results().size(), count / 2); } void tst_QtConcurrentFilter::noDetach() |