diff options
Diffstat (limited to 'tests/auto/concurrent')
19 files changed, 1209 insertions, 1610 deletions
diff --git a/tests/auto/concurrent/CMakeLists.txt b/tests/auto/concurrent/CMakeLists.txt new file mode 100644 index 0000000000..2ef8cfd128 --- /dev/null +++ b/tests/auto/concurrent/CMakeLists.txt @@ -0,0 +1,9 @@ +# Generated from concurrent.pro. + +add_subdirectory(qtconcurrentfilter) +add_subdirectory(qtconcurrentiteratekernel) +add_subdirectory(qtconcurrentmap) +add_subdirectory(qtconcurrentmedian) +add_subdirectory(qtconcurrentrun) +add_subdirectory(qtconcurrentthreadengine) +add_subdirectory(qtconcurrenttask) diff --git a/tests/auto/concurrent/concurrent.pro b/tests/auto/concurrent/concurrent.pro index e67c51aae3..ad3231ff90 100644 --- a/tests/auto/concurrent/concurrent.pro +++ b/tests/auto/concurrent/concurrent.pro @@ -5,5 +5,6 @@ SUBDIRS=\ qtconcurrentmap \ qtconcurrentmedian \ qtconcurrentrun \ - qtconcurrentthreadengine + qtconcurrentthreadengine \ + qtconcurrenttask diff --git a/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt b/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt new file mode 100644 index 0000000000..be8c936c48 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentfilter/.prev_CMakeLists.txt @@ -0,0 +1,12 @@ +# 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 new file mode 100644 index 0000000000..7868906178 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentfilter/CMakeLists.txt @@ -0,0 +1,12 @@ +# Generated from qtconcurrentfilter.pro. + +##################################################################### +## tst_qtconcurrentfilter Test: +##################################################################### + +qt_add_test(tst_qtconcurrentfilter + SOURCES + tst_qtconcurrentfilter.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) diff --git a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro b/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro index 15345d40db..f2e3e0c8e1 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro +++ b/tests/auto/concurrent/qtconcurrentfilter/qtconcurrentfilter.pro @@ -2,5 +2,3 @@ CONFIG += testcase TARGET = tst_qtconcurrentfilter QT = core testlib concurrent SOURCES = tst_qtconcurrentfilter.cpp -DEFINES += QT_STRICT_ITERATORS -DEFINES -= QT_NO_LINKED_LIST diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp index bd55446515..1b52f52038 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp +++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp @@ -28,7 +28,6 @@ #include <qtconcurrentfilter.h> #include <QCoreApplication> #include <QList> -#include <QLinkedList> #include <QtTest/QtTest> #include "../qtconcurrentmap/functions.h" @@ -45,6 +44,7 @@ private slots: void incrementalResults(); void noDetach(); void stlContainers(); + void filteredReduceInitialValue(); }; void tst_QtConcurrentFilter::filter() @@ -116,69 +116,6 @@ void tst_QtConcurrentFilter::filter() QtConcurrent::blockingFilter(list, &Number::isEven); QCOMPARE(list, QList<Number>() << 2 << 4); } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - // functor - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::filter(linkedList, KeepEvenIntegers()).waitForFinished(); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::blockingFilter(linkedList, KeepEvenIntegers()); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - - // function - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished(); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::blockingFilter(linkedList, keepEvenIntegers); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - - // bound function - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::filter(linkedList, keepEvenIntegers).waitForFinished(); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::blockingFilter(linkedList, keepEvenIntegers); - QCOMPARE(linkedList, QLinkedList<int>() << 2 << 4); - } - - // member - { - QLinkedList<Number> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::filter(linkedList, &Number::isEven).waitForFinished(); - QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4); - } - { - QLinkedList<Number> linkedList; - linkedList << 1 << 2 << 3 << 4; - QtConcurrent::blockingFilter(linkedList, &Number::isEven); - QCOMPARE(linkedList, QLinkedList<Number>() << 2 << 4); - } - -QT_WARNING_POP -#endif } void tst_QtConcurrentFilter::filtered() @@ -353,179 +290,6 @@ void tst_QtConcurrentFilter::filtered() &Number::isEven); QCOMPARE(list2, QList<Number>() << 2 << 4); } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - // same thing on linked lists - - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - - // functor - { - QFuture<int> f = QtConcurrent::filtered(linkedList, KeepEvenIntegers()); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers()); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers()); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, KeepEvenIntegers()); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers()); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers()); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - - // function - { - QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.begin(), - linkedList.end(), - keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(), - linkedList.end(), - keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - - // bound function - { - QFuture<int> f = QtConcurrent::filtered(linkedList, keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.begin(), - linkedList.end(), - keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QFuture<int> f = QtConcurrent::filtered(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers); - QList<int> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered(linkedList, keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.begin(), - linkedList.end(), - keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); - } - - // const member function - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QFuture<Number> f = QtConcurrent::filtered(integers, &Number::isEven); - QList<Number> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<Number>() << 2 << 4); - } - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QFuture<Number> f = QtConcurrent::filtered(integers.begin(), - integers.end(), - &Number::isEven); - QList<Number> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<Number>() << 2 << 4); - } - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QFuture<Number> f = QtConcurrent::filtered(integers.constBegin(), - integers.constEnd(), - &Number::isEven); - QList<Number> linkedList2 = f.results(); - QCOMPARE(linkedList2, QList<Number>() << 2 << 4); - } - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered(integers, &Number::isEven); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); - } - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.begin(), - integers.end(), - &Number::isEven); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); - } - { - QLinkedList<Number> integers; - integers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = - QtConcurrent::blockingFiltered<QLinkedList<Number> >(integers.constBegin(), - integers.constEnd(), - &Number::isEven); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); - } - -QT_WARNING_POP -#endif } void tst_QtConcurrentFilter::filteredReduced() @@ -723,16 +487,17 @@ void tst_QtConcurrentFilter::filteredReduced() QCOMPARE(sum, 6); } + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); // functor-member { - QList<int> list2 = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), &QList<int>::push_back, QtConcurrent::OrderedReduce); + QList<int> list2 = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { QList<int> list2 = QtConcurrent::filteredReduced(list.begin(), list.end(), KeepEvenIntegers(), - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -740,19 +505,19 @@ void tst_QtConcurrentFilter::filteredReduced() QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(), list.constEnd(), KeepEvenIntegers(), - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { - QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), &QList<int>::push_back, QtConcurrent::OrderedReduce); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(), list.end(), KeepEvenIntegers(), - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -760,7 +525,7 @@ void tst_QtConcurrentFilter::filteredReduced() QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(), list.constEnd(), KeepEvenIntegers(), - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -814,12 +579,15 @@ void tst_QtConcurrentFilter::filteredReduced() } // member-member + + auto push_back_number = static_cast<void (QVector<Number>::*)(const Number &)>(&QVector<Number>::push_back); + { QList<Number> numbers; numbers << 1 << 2 << 3 << 4; QList<Number> list2 = QtConcurrent::filteredReduced(numbers, &Number::isEven, - &QList<Number>::push_back, QtConcurrent::OrderedReduce); + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } { @@ -828,7 +596,7 @@ void tst_QtConcurrentFilter::filteredReduced() QList<Number> list2 = QtConcurrent::filteredReduced(numbers.begin(), numbers.end(), &Number::isEven, - &QList<Number>::push_back, + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } @@ -838,7 +606,7 @@ void tst_QtConcurrentFilter::filteredReduced() QList<Number> list2 = QtConcurrent::filteredReduced(numbers.constBegin(), numbers.constEnd(), &Number::isEven, - &QList<Number>::push_back, + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } @@ -847,7 +615,7 @@ void tst_QtConcurrentFilter::filteredReduced() numbers << 1 << 2 << 3 << 4; QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers, &Number::isEven, - &QList<Number>::push_back, QtConcurrent::OrderedReduce); + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } { @@ -856,7 +624,7 @@ void tst_QtConcurrentFilter::filteredReduced() QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.begin(), numbers.end(), &Number::isEven, - &QList<Number>::push_back, + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } @@ -866,21 +634,21 @@ void tst_QtConcurrentFilter::filteredReduced() QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(), numbers.constEnd(), &Number::isEven, - &QList<Number>::push_back, + push_back_number, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<Number>() << 2 << 4); } // function-member { - QList<int> list2 = QtConcurrent::filteredReduced(list, keepEvenIntegers, &QList<int>::push_back, QtConcurrent::OrderedReduce); + QList<int> list2 = QtConcurrent::filteredReduced(list, keepEvenIntegers, push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { QList<int> list2 = QtConcurrent::filteredReduced(list.begin(), list.end(), keepEvenIntegers, - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -888,19 +656,19 @@ void tst_QtConcurrentFilter::filteredReduced() QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(), list.constEnd(), keepEvenIntegers, - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { - QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, &QList<int>::push_back, QtConcurrent::OrderedReduce); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } { QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(), list.end(), keepEvenIntegers, - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -908,7 +676,7 @@ void tst_QtConcurrentFilter::filteredReduced() QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(), list.constEnd(), keepEvenIntegers, - &QList<int>::push_back, + push_back, QtConcurrent::OrderedReduce); QCOMPARE(list2, QList<int>() << 2 << 4); } @@ -961,567 +729,554 @@ void tst_QtConcurrentFilter::filteredReduced() QCOMPARE(sum, 6); } -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED +} + +bool filterfn(int i) +{ + return (i % 2); +} + +void tst_QtConcurrentFilter::resultAt() +{ + + QList<int> ints; + for (int i=0; i < 1000; ++i) + ints << i; + + QFuture<int> future = QtConcurrent::filtered(ints, filterfn); + future.waitForFinished(); + + for (int i = 0; i < future.resultCount(); ++i) { + QCOMPARE(future.resultAt(i), ints.at(i * 2 + 1)); + } + +} - // same as above on linked lists - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3 << 4; - QLinkedList<Number> numberLinkedList; - numberLinkedList << 1 << 2 << 3 << 4; +bool waitFilterfn(const int &i) +{ + QTest::qWait(1); + return (i % 2); +} + +void tst_QtConcurrentFilter::incrementalResults() +{ + const int count = 200; + QList<int> ints; + for (int i=0; i < count; ++i) + ints << i; + + QFuture<int> future = QtConcurrent::filtered(ints, waitFilterfn); + + QList<int> results; + + while (future.isFinished() == false) { + for (int i = 0; i < future.resultCount(); ++i) { + results += future.resultAt(i); + } + QTest::qWait(1); + } + + QCOMPARE(future.isFinished(), true); + QCOMPARE(future.resultCount(), count / 2); + QCOMPARE(future.results().count(), count / 2); +} + +void tst_QtConcurrentFilter::noDetach() +{ + { + QList<int> l = QList<int>() << 1; + QVERIFY(l.isDetached()); + + QList<int> ll = l; + QVERIFY(!l.isDetached()); + + QtConcurrent::filtered(l, waitFilterfn).waitForFinished(); + + QVERIFY(!l.isDetached()); + QVERIFY(!ll.isDetached()); + + QtConcurrent::blockingFiltered(l, waitFilterfn); + + QVERIFY(!l.isDetached()); + QVERIFY(!ll.isDetached()); + + QtConcurrent::filteredReduced(l, waitFilterfn, intSumReduce).waitForFinished(); + + QVERIFY(!l.isDetached()); + QVERIFY(!ll.isDetached()); + + QtConcurrent::filter(l, waitFilterfn).waitForFinished(); + if (!l.isDetached()) + QEXPECT_FAIL("", "QTBUG-20688: Known unstable failure", Abort); + QVERIFY(l.isDetached()); + QVERIFY(ll.isDetached()); + } + { + const QList<int> l = QList<int>() << 1; + QVERIFY(l.isDetached()); + + const QList<int> ll = l; + QVERIFY(!l.isDetached()); + + QtConcurrent::filtered(l, waitFilterfn).waitForFinished(); + + QVERIFY(!l.isDetached()); + QVERIFY(!ll.isDetached()); + + QtConcurrent::filteredReduced(l, waitFilterfn, intSumReduce).waitForFinished(); + + QVERIFY(!l.isDetached()); + QVERIFY(!ll.isDetached()); + } +} + +void tst_QtConcurrentFilter::stlContainers() +{ + std::vector<int> vector; + vector.push_back(1); + vector.push_back(2); + + std::vector<int> vector2 = QtConcurrent::blockingFiltered(vector, waitFilterfn); + QCOMPARE(vector2.size(), (std::vector<int>::size_type)(1)); + QCOMPARE(vector2[0], 1); + + std::list<int> list; + list.push_back(1); + list.push_back(2); + + std::list<int> list2 = QtConcurrent::blockingFiltered(list, waitFilterfn); + QCOMPARE(list2.size(), (std::list<int>::size_type)(1)); + QCOMPARE(*list2.begin(), 1); + + QtConcurrent::filtered(list, waitFilterfn).waitForFinished(); + QtConcurrent::filtered(vector, waitFilterfn).waitForFinished(); + QtConcurrent::filtered(vector.begin(), vector.end(), waitFilterfn).waitForFinished(); + + QtConcurrent::blockingFilter(list, waitFilterfn); + QCOMPARE(list2.size(), (std::list<int>::size_type)(1)); + QCOMPARE(*list2.begin(), 1); +} + +void tst_QtConcurrentFilter::filteredReduceInitialValue() +{ + // This test's the same as filteredReduce, but with an initial value on all calls + QList<int> list; + list << 1 << 2 << 3 << 4; + QList<Number> numberList; + numberList << 1 << 2 << 3 << 4; // functor-functor { - int sum = QtConcurrent::filteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>(list, KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - IntSumReduce()); - QCOMPARE(sum, 6); + QVector<int> vector; + vector << 1 << 2 << 3 << 4; + int sum = + QtConcurrent::filteredReduced<int>(vector, KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); + } + { + int sum = QtConcurrent::filteredReduced<int>( + list.begin(), list.end(), KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::filteredReduced<int>(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::filteredReduced<int>( + list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>( + list.constBegin(), list.constEnd(), KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::filteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::filteredReduced<int>( + list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, KeepEvenIntegers(), IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list, KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::blockingFilteredReduced<int>( + list, keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list.begin(), list.end(), KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::blockingFilteredReduced<int>( + list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list.constBegin(), list.constEnd(), KeepEvenIntegers(), IntSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::blockingFilteredReduced<int>( + list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum2, 16); } // function-functor { - int sum = QtConcurrent::filteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>(list, keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced<int>(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>( + list.begin(), list.end(), keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>( + list.constBegin(), list.constEnd(), keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList, keepEvenIntegers, IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list, keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list.begin(), list.end(), keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - IntSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + list.constBegin(), list.constEnd(), keepEvenIntegers, IntSumReduce(), 10); + QCOMPARE(sum, 16); } // functor-function { - int sum = QtConcurrent::filteredReduced(linkedList, KeepEvenIntegers(), intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced(list, KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced( + list.begin(), list.end(), KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced( + list.constBegin(), list.constEnd(), KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList, KeepEvenIntegers(), intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced(list, KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + list.begin(), list.end(), KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + list.constBegin(), list.constEnd(), KeepEvenIntegers(), intSumReduce, 10); + QCOMPARE(sum, 16); } // function-function { - int sum = QtConcurrent::filteredReduced(linkedList, keepEvenIntegers, intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced(list, keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced( + list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced( + list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList, keepEvenIntegers, intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced(list, keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + list.begin(), list.end(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - intSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + list.constBegin(), list.constEnd(), keepEvenIntegers, intSumReduce, 10); + QCOMPARE(sum, 16); } + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); // functor-member + QVector<int> initialIntVector; + initialIntVector.push_back(10); { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList, KeepEvenIntegers(), &QLinkedList<int>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced( + list, KeepEvenIntegers(), push_back, initialIntVector, QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced(list.begin(), + list.end(), + KeepEvenIntegers(), + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(), + list.constEnd(), + KeepEvenIntegers(), + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList, KeepEvenIntegers(), &QLinkedList<int>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced( + list, KeepEvenIntegers(), push_back, initialIntVector, QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.begin(), - linkedList.end(), - KeepEvenIntegers(), - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(), + list.end(), + KeepEvenIntegers(), + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - KeepEvenIntegers(), - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(), + list.constEnd(), + KeepEvenIntegers(), + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } // member-functor { - int sum = QtConcurrent::filteredReduced<int>(numberLinkedList, &Number::isEven, NumberSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>( + numberList, &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::filteredReduced<int>(QLinkedList<Number>(numberLinkedList), - &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::filteredReduced<int>( + QList<Number>(numberList), &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::filteredReduced<int>(numberLinkedList.begin(), - numberLinkedList.end(), - &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced<int>( + numberList.begin(), numberList.end(), &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced<int>(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), + int sum = QtConcurrent::filteredReduced<int>(numberList.constBegin(), + numberList.constEnd(), &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum, 6); + NumberSumReduce(), + 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList, &Number::isEven, NumberSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + numberList, &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::blockingFilteredReduced<int>(QLinkedList<Number>(numberLinkedList), - &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::blockingFilteredReduced<int>( + QList<Number>(numberList), &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList.begin(), - numberLinkedList.end(), - &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced<int>( + numberList.begin(), numberList.end(), &Number::isEven, NumberSumReduce(), 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced<int>(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), + int sum = QtConcurrent::blockingFilteredReduced<int>(numberList.constBegin(), + numberList.constEnd(), &Number::isEven, - NumberSumReduce()); - QCOMPARE(sum, 6); + NumberSumReduce(), + 10); + QCOMPARE(sum, 16); } // member-member + + auto push_back_number = + static_cast<void (QVector<Number>::*)(const Number &)>(&QVector<Number>::push_back); + QVector<Number> initialNumberVector { 10 }; { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers, - &Number::isEven, - &QLinkedList<Number>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::filteredReduced(numbers, + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers.begin(), - numbers.end(), - &Number::isEven, - &QLinkedList<Number>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::filteredReduced(numbers.begin(), + numbers.end(), + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::filteredReduced(numbers.constBegin(), - numbers.constEnd(), - &Number::isEven, - &QLinkedList<Number>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::filteredReduced(numbers.constBegin(), + numbers.constEnd(), + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers, - &Number::isEven, - &QLinkedList<Number>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers, + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers.begin(), - numbers.end(), - &Number::isEven, - &QLinkedList<Number>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.begin(), + numbers.end(), + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } { - QLinkedList<Number> numbers; + QList<Number> numbers; numbers << 1 << 2 << 3 << 4; - QLinkedList<Number> linkedList2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(), - numbers.constEnd(), - &Number::isEven, - &QLinkedList<Number>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<Number>() << 2 << 4); + QList<Number> list2 = QtConcurrent::blockingFilteredReduced(numbers.constBegin(), + numbers.constEnd(), + &Number::isEven, + push_back_number, + initialNumberVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<Number>() << 10 << 2 << 4); } // function-member { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList, keepEvenIntegers, &QLinkedList<int>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced( + list, keepEvenIntegers, push_back, initialIntVector, QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced(list.begin(), + list.end(), + keepEvenIntegers, + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::filteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::filteredReduced(list.constBegin(), + list.constEnd(), + keepEvenIntegers, + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList, keepEvenIntegers, &QLinkedList<int>::append, QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced( + list, keepEvenIntegers, push_back, initialIntVector, QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.begin(), - linkedList.end(), - keepEvenIntegers, - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.begin(), + list.end(), + keepEvenIntegers, + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } { - QLinkedList<int> linkedList2 = QtConcurrent::blockingFilteredReduced(linkedList.constBegin(), - linkedList.constEnd(), - keepEvenIntegers, - &QLinkedList<int>::append, - QtConcurrent::OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4); + QList<int> list2 = QtConcurrent::blockingFilteredReduced(list.constBegin(), + list.constEnd(), + keepEvenIntegers, + push_back, + initialIntVector, + QtConcurrent::OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 2 << 4); } // member-function { - int sum = QtConcurrent::filteredReduced(numberLinkedList, &Number::isEven, numberSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced(numberList, &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::filteredReduced(QLinkedList<Number>(numberLinkedList), - &Number::isEven, - numberSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::filteredReduced( + QList<Number>(numberList), &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::filteredReduced(numberLinkedList.begin(), - numberLinkedList.end(), - &Number::isEven, - numberSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::filteredReduced( + numberList.begin(), numberList.end(), &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::filteredReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), + int sum = QtConcurrent::filteredReduced(numberList.constBegin(), + numberList.constEnd(), &Number::isEven, - numberSumReduce); - QCOMPARE(sum, 6); + numberSumReduce, + 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList, &Number::isEven, numberSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + numberList, &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum, 16); - int sum2 = QtConcurrent::blockingFilteredReduced(QLinkedList<Number>(numberLinkedList), - &Number::isEven, - numberSumReduce); - QCOMPARE(sum2, 6); + int sum2 = QtConcurrent::blockingFilteredReduced( + QList<Number>(numberList), &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum2, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList.begin(), - numberLinkedList.end(), - &Number::isEven, - numberSumReduce); - QCOMPARE(sum, 6); + int sum = QtConcurrent::blockingFilteredReduced( + numberList.begin(), numberList.end(), &Number::isEven, numberSumReduce, 10); + QCOMPARE(sum, 16); } { - int sum = QtConcurrent::blockingFilteredReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), + int sum = QtConcurrent::blockingFilteredReduced(numberList.constBegin(), + numberList.constEnd(), &Number::isEven, - numberSumReduce); - QCOMPARE(sum, 6); - } - -QT_WARNING_POP -#endif - - // ### the same as above, with an initial result value -} - -bool filterfn(int i) -{ - return (i % 2); -} - -void tst_QtConcurrentFilter::resultAt() -{ - - QList<int> ints; - for (int i=0; i < 1000; ++i) - ints << i; - - QFuture<int> future = QtConcurrent::filtered(ints, filterfn); - future.waitForFinished(); - - for (int i = 0; i < future.resultCount(); ++i) { - QCOMPARE(future.resultAt(i), ints.at(i * 2 + 1)); - } - -} - -bool waitFilterfn(const int &i) -{ - QTest::qWait(1); - return (i % 2); -} - -void tst_QtConcurrentFilter::incrementalResults() -{ - const int count = 200; - QList<int> ints; - for (int i=0; i < count; ++i) - ints << i; - - QFuture<int> future = QtConcurrent::filtered(ints, waitFilterfn); - - QList<int> results; - - while (future.isFinished() == false) { - for (int i = 0; i < future.resultCount(); ++i) { - results += future.resultAt(i); - } - QTest::qWait(1); - } - - QCOMPARE(future.isFinished(), true); - QCOMPARE(future.resultCount(), count / 2); - QCOMPARE(future.results().count(), count / 2); -} - -void tst_QtConcurrentFilter::noDetach() -{ - { - QList<int> l = QList<int>() << 1; - QVERIFY(l.isDetached()); - - QList<int> ll = l; - QVERIFY(!l.isDetached()); - - QtConcurrent::filtered(l, waitFilterfn).waitForFinished(); - - QVERIFY(!l.isDetached()); - QVERIFY(!ll.isDetached()); - - QtConcurrent::blockingFiltered(l, waitFilterfn); - - QVERIFY(!l.isDetached()); - QVERIFY(!ll.isDetached()); - - QtConcurrent::filteredReduced(l, waitFilterfn, intSumReduce).waitForFinished(); - - QVERIFY(!l.isDetached()); - QVERIFY(!ll.isDetached()); - - QtConcurrent::filter(l, waitFilterfn).waitForFinished(); - if (!l.isDetached()) - QEXPECT_FAIL("", "QTBUG-20688: Known unstable failure", Abort); - QVERIFY(l.isDetached()); - QVERIFY(ll.isDetached()); - } - { - const QList<int> l = QList<int>() << 1; - QVERIFY(l.isDetached()); - - const QList<int> ll = l; - QVERIFY(!l.isDetached()); - - QtConcurrent::filtered(l, waitFilterfn).waitForFinished(); - - QVERIFY(!l.isDetached()); - QVERIFY(!ll.isDetached()); - - QtConcurrent::filteredReduced(l, waitFilterfn, intSumReduce).waitForFinished(); - - QVERIFY(!l.isDetached()); - QVERIFY(!ll.isDetached()); + numberSumReduce, + 10); + QCOMPARE(sum, 16); } } -void tst_QtConcurrentFilter::stlContainers() -{ - std::vector<int> vector; - vector.push_back(1); - vector.push_back(2); - - std::vector<int> vector2 = QtConcurrent::blockingFiltered(vector, waitFilterfn); - QCOMPARE(vector2.size(), (std::vector<int>::size_type)(1)); - QCOMPARE(vector2[0], 1); - - std::list<int> list; - list.push_back(1); - list.push_back(2); - - std::list<int> list2 = QtConcurrent::blockingFiltered(list, waitFilterfn); - QCOMPARE(list2.size(), (std::list<int>::size_type)(1)); - QCOMPARE(*list2.begin(), 1); - - QtConcurrent::filtered(list, waitFilterfn).waitForFinished(); - QtConcurrent::filtered(vector, waitFilterfn).waitForFinished(); - QtConcurrent::filtered(vector.begin(), vector.end(), waitFilterfn).waitForFinished(); - - QtConcurrent::blockingFilter(list, waitFilterfn); - QCOMPARE(list2.size(), (std::list<int>::size_type)(1)); - QCOMPARE(*list2.begin(), 1); -} - QTEST_MAIN(tst_QtConcurrentFilter) #include "tst_qtconcurrentfilter.moc" diff --git a/tests/auto/concurrent/qtconcurrentiteratekernel/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentiteratekernel/CMakeLists.txt new file mode 100644 index 0000000000..af44d66642 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentiteratekernel/CMakeLists.txt @@ -0,0 +1,12 @@ +# Generated from qtconcurrentiteratekernel.pro. + +##################################################################### +## tst_qtconcurrentiteratekernel Test: +##################################################################### + +add_qt_test(tst_qtconcurrentiteratekernel + SOURCES + tst_qtconcurrentiteratekernel.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) diff --git a/tests/auto/concurrent/qtconcurrentmap/.prev_CMakeLists.txt b/tests/auto/concurrent/qtconcurrentmap/.prev_CMakeLists.txt new file mode 100644 index 0000000000..be51bf09bd --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentmap/.prev_CMakeLists.txt @@ -0,0 +1,17 @@ +# Generated from qtconcurrentmap.pro. + +##################################################################### +## tst_qtconcurrentmap Test: +##################################################################### + +add_qt_test(tst_qtconcurrentmap + SOURCES + tst_qtconcurrentmap.cpp + DEFINES + -QT_NO_LINKED_LIST + PUBLIC_LIBRARIES + Qt::Concurrent +) + +## Scopes: +##################################################################### diff --git a/tests/auto/concurrent/qtconcurrentmap/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentmap/CMakeLists.txt new file mode 100644 index 0000000000..c14780e0de --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentmap/CMakeLists.txt @@ -0,0 +1,15 @@ +# Generated from qtconcurrentmap.pro. + +##################################################################### +## tst_qtconcurrentmap Test: +##################################################################### + +qt_add_test(tst_qtconcurrentmap + SOURCES + tst_qtconcurrentmap.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) + +## Scopes: +##################################################################### diff --git a/tests/auto/concurrent/qtconcurrentmap/qtconcurrentmap.pro b/tests/auto/concurrent/qtconcurrentmap/qtconcurrentmap.pro index 717d103e44..bbadd1ada1 100644 --- a/tests/auto/concurrent/qtconcurrentmap/qtconcurrentmap.pro +++ b/tests/auto/concurrent/qtconcurrentmap/qtconcurrentmap.pro @@ -2,8 +2,6 @@ CONFIG += testcase TARGET = tst_qtconcurrentmap QT = core testlib concurrent SOURCES = tst_qtconcurrentmap.cpp -DEFINES += QT_STRICT_ITERATORS -DEFINES -= QT_NO_LINKED_LIST # Force C++17 if available contains(QT_CONFIG, c++1z): CONFIG += c++1z diff --git a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp index ad62f6cdf1..1a8978c7ea 100644 --- a/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp +++ b/tests/auto/concurrent/qtconcurrentmap/tst_qtconcurrentmap.cpp @@ -58,6 +58,8 @@ private slots: void qFutureAssignmentLeak(); void stressTest(); void persistentResultTest(); + void mappedReducedInitialValue(); + void blocking_mappedReducedInitialValue(); public slots: void throttling(); }; @@ -164,43 +166,6 @@ void tst_QtConcurrentMap::map() QCOMPARE(list, QList<int>() << 1 << 2 << 3); } -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - // Linked lists and forward iterators - { - QLinkedList<int> list; - list << 1 << 2 << 3; - - // functor - QtConcurrent::map(list, MultiplyBy2InPlace()).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 2 << 4 << 6); - QtConcurrent::map(list.begin(), list.end(), MultiplyBy2InPlace()).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 4 << 8 << 12); - - // function - QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 8 << 16 << 24); - QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 16 << 32 << 48); - - // bound function - QtConcurrent::map(list, multiplyBy2InPlace).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 32 << 64 << 96); - QtConcurrent::map(list.begin(), list.end(), multiplyBy2InPlace).waitForFinished(); - QCOMPARE(list, QLinkedList<int>() << 64 << 128 << 192); - - // member function - QLinkedList<Number> numberList; - numberList << 1 << 2 << 3; - QtConcurrent::map(numberList, &Number::multiplyBy2).waitForFinished(); - QCOMPARE(numberList, QLinkedList<Number>() << 2 << 4 << 6); - QtConcurrent::map(numberList.begin(), numberList.end(), &Number::multiplyBy2).waitForFinished(); - QCOMPARE(numberList, QLinkedList<Number>() << 4 << 8 << 12); - } -QT_WARNING_POP -#endif - #if 0 // not allowed: map() with immutable sequences makes no sense { @@ -301,43 +266,6 @@ void tst_QtConcurrentMap::blocking_map() QCOMPARE(list, QList<int>() << 1 << 2 << 3); } -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - // Linked lists and forward iterators - { - QLinkedList<int> list; - list << 1 << 2 << 3; - - // functor - QtConcurrent::blockingMap(list, MultiplyBy2InPlace()); - QCOMPARE(list, QLinkedList<int>() << 2 << 4 << 6); - QtConcurrent::blockingMap(list.begin(), list.end(), MultiplyBy2InPlace()); - QCOMPARE(list, QLinkedList<int>() << 4 << 8 << 12); - - // function - QtConcurrent::blockingMap(list, multiplyBy2InPlace); - QCOMPARE(list, QLinkedList<int>() << 8 << 16 << 24); - QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace); - QCOMPARE(list, QLinkedList<int>() << 16 << 32 << 48); - - // bound function - QtConcurrent::blockingMap(list, multiplyBy2InPlace); - QCOMPARE(list, QLinkedList<int>() << 32 << 64 << 96); - QtConcurrent::blockingMap(list.begin(), list.end(), multiplyBy2InPlace); - QCOMPARE(list, QLinkedList<int>() << 64 << 128 << 192); - - // member function - QLinkedList<Number> numberList; - numberList << 1 << 2 << 3; - QtConcurrent::blockingMap(numberList, &Number::multiplyBy2); - QCOMPARE(numberList, QLinkedList<Number>() << 2 << 4 << 6); - QtConcurrent::blockingMap(numberList.begin(), numberList.end(), &Number::multiplyBy2); - QCOMPARE(numberList, QLinkedList<Number>() << 4 << 8 << 12); - } -QT_WARNING_POP -#endif - #if 0 // not allowed: map() with immutable sequences makes no sense { @@ -646,175 +574,6 @@ void tst_QtConcurrentMap::mapped() .results(); QCOMPARE(list2, QList<int>() << 1 << 2 << 3); } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3; - QLinkedList<Number> numberLinkedList; - numberLinkedList << 1 << 2 << 3; - - // functor - { - QList<int> list2 = QtConcurrent::mapped(linkedList, MultiplyBy2()).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<int>() << 2 << 4 << 6); - - QList<int> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - MultiplyBy2()).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<int>() << 2 << 4 << 6); - - QList<int> list4 = - QtConcurrent::mapped(QLinkedList<int>(linkedList), MultiplyBy2()).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<int>() << 2 << 4 << 6); - } - - // function - { - QList<int> list2 = QtConcurrent::mapped(linkedList, multiplyBy2).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<int>() << 2 << 4 << 6); - - QList<int> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - multiplyBy2).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<int>() << 2 << 4 << 6); - - QList<int> list4 = - QtConcurrent::mapped(QLinkedList<int>(linkedList), multiplyBy2).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<int>() << 2 << 4 << 6); - } - - // bound function - { - QList<int> list2 = QtConcurrent::mapped(linkedList, multiplyBy2).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<int>() << 2 << 4 << 6); - - QList<int> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - multiplyBy2) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<int>() << 2 << 4 << 6); - - QList<int> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), multiplyBy2) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<int>() << 2 << 4 << 6); - } - - // const member function - { - QList<Number> numberList2 = QtConcurrent::mapped(numberLinkedList, &Number::multipliedBy2) - .results(); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberList2, QList<Number>() << 2 << 4 << 6); - - QList<Number> numberList3 = QtConcurrent::mapped(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::multipliedBy2) - .results(); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberList3, QList<Number>() << 2 << 4 << 6); - - QList<Number> numberList4 = QtConcurrent::mapped(QLinkedList<Number>(numberLinkedList), - &Number::multipliedBy2) - .results(); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberList4, QList<Number>() << 2 << 4 << 6); - } - - // change the value_type, same container - - // functor - { - QList<double> list2 = QtConcurrent::mapped(linkedList, IntToDouble()).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0); - - QList<double> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - IntToDouble()) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0); - - QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), - IntToDouble()) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0); - } - - // function - { - QList<double> list2 = QtConcurrent::mapped(linkedList, intToDouble).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0); - - QList<double> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - intToDouble) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0); - - QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), intToDouble) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0); - } - - // bound function - { - QList<double> list2 = QtConcurrent::mapped(linkedList, intToDouble).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<double>() << 1.0 << 2.0 << 3.0); - - QList<double> list3 = QtConcurrent::mapped(linkedList.constBegin(), - linkedList.constEnd(), - intToDouble) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<double>() << 1.0 << 2.0 << 3.0); - - - QList<double> list4 = QtConcurrent::mapped(QLinkedList<int>(linkedList), - intToDouble) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<double>() << 1.0 << 2.0 << 3.0); - } - - // const member function - { - QList<QString> list2 = QtConcurrent::mapped(numberLinkedList, &Number::toString).results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list2, QList<QString>() << "1" << "2" << "3"); - - QList<QString> list3 = QtConcurrent::mapped(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toString) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list3, QList<QString>() << "1" << "2" << "3"); - - QList<QString> list4 = QtConcurrent::mapped(QLinkedList<Number>(numberLinkedList), - &Number::toString) - .results(); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(list4, QList<QString>() << "1" << "2" << "3"); - } -QT_WARNING_POP -#endif } void tst_QtConcurrentMap::blocking_mapped() @@ -1123,162 +882,6 @@ void tst_QtConcurrentMap::blocking_mapped() QCOMPARE(list5, QVector<int>() << 1 << 2 << 3); #endif } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3; - QLinkedList<Number> numberLinkedList; - numberLinkedList << 1 << 2 << 3; - - // functor - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, MultiplyBy2()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - MultiplyBy2()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), MultiplyBy2()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 2 << 4 << 6); - } - - // function - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 2 << 4 << 6); - } - - // bound function - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMapped(linkedList, multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<int> >(linkedList.constBegin(), - linkedList.constEnd(), - multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 2 << 4 << 6); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMapped(QLinkedList<int>(linkedList), multiplyBy2); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 2 << 4 << 6); - } - - // const member function - { - QLinkedList<Number> numberLinkedList2 = QtConcurrent::blockingMapped(numberLinkedList, &Number::multipliedBy2); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberLinkedList2, QLinkedList<Number>() << 2 << 4 << 6); - - QLinkedList<Number> numberLinkedList3 = QtConcurrent::blockingMapped<QLinkedList<Number> >(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::multipliedBy2); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberLinkedList3, QLinkedList<Number>() << 2 << 4 << 6); - - QLinkedList<Number> numberLinkedList4 = QtConcurrent::blockingMapped(QLinkedList<Number>(numberLinkedList), - &Number::multipliedBy2); - QCOMPARE(numberLinkedList, QLinkedList<Number>() << 1 << 2 << 3); - QCOMPARE(numberLinkedList4, QLinkedList<Number>() << 2 << 4 << 6); - } - - // change the value_type, same container - - // functor - { - QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, IntToDouble()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(), - linkedList.constEnd(), - IntToDouble()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList), - IntToDouble()); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - } - - // function - { - QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(), - linkedList.constEnd(), - intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList), intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - } - - // bound function - { - QLinkedList<double> linkedList2 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList, intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - QLinkedList<double> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<double> >(linkedList.constBegin(), - linkedList.constEnd(), - intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - - - QLinkedList<double> linkedList4 = QtConcurrent::blockingMapped<QLinkedList<double> >(QLinkedList<int>(linkedList), - intToDouble); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<double>() << 1.0 << 2.0 << 3.0); - } - - // const member function - { - QLinkedList<QString> linkedList2 = - QtConcurrent::blockingMapped<QLinkedList<QString> >(numberLinkedList, &Number::toString); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<QString>() << "1" << "2" << "3"); - - QLinkedList<QString> linkedList3 = QtConcurrent::blockingMapped<QLinkedList<QString> >(numberLinkedList.constBegin(), - numberLinkedList.constEnd() - , &Number::toString); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<QString>() << "1" << "2" << "3"); - - QLinkedList<QString> linkedList4 = - QtConcurrent::blockingMapped<QLinkedList<QString> >(QLinkedList<Number>(numberLinkedList), &Number::toString); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<QString>() << "1" << "2" << "3"); - } - -QT_WARNING_POP -#endif } int intSquare(int x) @@ -1377,11 +980,13 @@ void tst_QtConcurrentMap::mappedReduced() QCOMPARE(sum3, 14); } + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); + // functor-member { QList<int> list2 = QtConcurrent::mappedReduced(list, IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list2, QList<int>() << 1 << 4 << 9); @@ -1389,14 +994,14 @@ void tst_QtConcurrentMap::mappedReduced() QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(), list.constEnd(), IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list3, QList<int>() << 1 << 4 << 9); QList<int> list4 = QtConcurrent::mappedReduced(QList<int>(list), IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list4, QList<int>() << 1 << 4 << 9); @@ -1422,20 +1027,20 @@ void tst_QtConcurrentMap::mappedReduced() { QList<int> list2 = QtConcurrent::mappedReduced(numberList, &Number::toInt, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list2, QList<int>() << 1 << 2 << 3); QList<int> list3 = QtConcurrent::mappedReduced(numberList.constBegin(), numberList.constEnd(), &Number::toInt, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list3, QList<int>() << 1 << 2 << 3); QList<int> list4 = QtConcurrent::mappedReduced(QList<Number>(numberList), &Number::toInt, - &QList<int>::push_back, OrderedReduce); + push_back, OrderedReduce); QCOMPARE(list4, QList<int>() << 1 << 2 << 3); } @@ -1443,7 +1048,7 @@ void tst_QtConcurrentMap::mappedReduced() { QList<int> list2 = QtConcurrent::mappedReduced(list, intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list2, QList<int>() << 1 << 4 << 9); @@ -1451,14 +1056,14 @@ void tst_QtConcurrentMap::mappedReduced() QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(), list.constEnd(), intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list3, QList<int>() << 1 << 4 << 9); QList<int> list4 = QtConcurrent::mappedReduced(QList<int>(list), intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list4, QList<int>() << 1 << 4 << 9); @@ -1481,228 +1086,6 @@ void tst_QtConcurrentMap::mappedReduced() intSumReduce); QCOMPARE(sum3, 6); } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3; - QLinkedList<Number> numberLinkedList; - numberLinkedList << 1 << 2 << 3; - - // functor-functor - { - int sum = QtConcurrent::mappedReduced<int>(linkedList, IntSquare(), IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::mappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::mappedReduced<int>(QLinkedList<int>(linkedList), IntSquare(), IntSumReduce()); - QCOMPARE(sum3, 14); - - int sum4 = QtConcurrent::mappedReduced<int>(linkedList, intSquare, intSumReduce); - QCOMPARE(sum4, 14); - int sum5 = QtConcurrent::mappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum5, 14); - - int sum6 = QtConcurrent::mappedReduced<int>(QLinkedList<int>(linkedList), - intSquare, - intSumReduce); - QCOMPARE(sum6, 14); - } - - // function-functor - { - int sum = QtConcurrent::mappedReduced<int>(linkedList, intSquare, IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::mappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::mappedReduced<int>(QLinkedList<int>(linkedList), intSquare, IntSumReduce()); - QCOMPARE(sum3, 14); - } - - // functor-function - { - int sum = QtConcurrent::mappedReduced(linkedList, IntSquare(), intSumReduce); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::mappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - intSumReduce); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::mappedReduced(QLinkedList<int>(linkedList), IntSquare(), intSumReduce); - QCOMPARE(sum3, 14); - } - - // function-function - { - int sum = QtConcurrent::mappedReduced(linkedList, intSquare, intSumReduce); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::mappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::mappedReduced(QLinkedList<int>(linkedList), intSquare, intSumReduce); - QCOMPARE(sum3, 14); - } - - // functor-member - { - QLinkedList<int> linkedList2 = QtConcurrent::mappedReduced(linkedList, - IntSquare(), - &QLinkedList<int>::push_back, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList3 = QtConcurrent::mappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - &QLinkedList<int>::push_back, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList4 = QtConcurrent::mappedReduced(QLinkedList<int>(linkedList), - IntSquare(), - &QLinkedList<int>::push_back, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 4 << 9); - } - - // member-functor - { - int sum = QtConcurrent::mappedReduced<int>(numberLinkedList, &Number::toInt, IntSumReduce()); - QCOMPARE(sum, 6); - int sum2 = QtConcurrent::mappedReduced<int>(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - IntSumReduce()); - QCOMPARE(sum2, 6); - - int sum3 = QtConcurrent::mappedReduced<int>(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - IntSumReduce()); - QCOMPARE(sum3, 6); - } - - // member-member - { - QLinkedList<int> linkedList2 = QtConcurrent::mappedReduced(numberLinkedList, - &Number::toInt, - &QLinkedList<int>::push_back, - OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 2 << 3); - - QLinkedList<int> linkedList3 = QtConcurrent::mappedReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - &QLinkedList<int>::push_back, - OrderedReduce); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 2 << 3); - - QLinkedList<int> linkedList4 = QtConcurrent::mappedReduced(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - &QLinkedList<int>::push_back, OrderedReduce); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 2 << 3); - } - - // function-member - { - QLinkedList<int> linkedList2 = QtConcurrent::mappedReduced(linkedList, - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList3 = QtConcurrent::mappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList4 = QtConcurrent::mappedReduced(QLinkedList<int>(linkedList), - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 4 << 9); - } - - // member-function - { - int sum = QtConcurrent::mappedReduced(numberLinkedList, - &Number::toInt, - intSumReduce); - QCOMPARE(sum, 6); - int sum2 = QtConcurrent::mappedReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - intSumReduce); - QCOMPARE(sum2, 6); - - int sum3 = QtConcurrent::mappedReduced(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - intSumReduce); - QCOMPARE(sum3, 6); - } - - // linked lists - { - - QLinkedList<int> list; - list << 1 << 2 << 3; - - QLinkedList<Number> numberList; - numberList << 1 << 2 << 3; - - int sum = QtConcurrent::mappedReduced<int>(list, IntSquare(), IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::mappedReduced<int>(list.constBegin(), - list.constEnd(), - IntSquare(), - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::mappedReduced<int>(QLinkedList<int>(list), IntSquare(), IntSumReduce()); - QCOMPARE(sum3, 14); - - int sum4 = QtConcurrent::mappedReduced<int>(list, intSquare, intSumReduce); - QCOMPARE(sum4, 14); - int sum5 = QtConcurrent::mappedReduced<int>(list.constBegin(), - list.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum5, 14); - - int sum6 = QtConcurrent::mappedReduced<int>(QLinkedList<int>(list), - intSquare, - intSumReduce); - QCOMPARE(sum6, 14); - } - -QT_WARNING_POP -#endif - - // ### the same as above, with an initial result value } void tst_QtConcurrentMap::blocking_mappedReduced() @@ -1781,11 +1164,13 @@ void tst_QtConcurrentMap::blocking_mappedReduced() QCOMPARE(sum3, 14); } + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); + // functor-member { QList<int> list2 = QtConcurrent::blockingMappedReduced(list, IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list2, QList<int>() << 1 << 4 << 9); @@ -1793,14 +1178,14 @@ void tst_QtConcurrentMap::blocking_mappedReduced() QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(), list.constEnd(), IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list3, QList<int>() << 1 << 4 << 9); QList<int> list4 = QtConcurrent::blockingMappedReduced(QList<int>(list), IntSquare(), - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list4, QList<int>() << 1 << 4 << 9); @@ -1827,20 +1212,20 @@ void tst_QtConcurrentMap::blocking_mappedReduced() { QList<int> list2 = QtConcurrent::blockingMappedReduced(numberList, &Number::toInt, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list2, QList<int>() << 1 << 2 << 3); QList<int> list3 = QtConcurrent::blockingMappedReduced(numberList.constBegin(), numberList.constEnd(), &Number::toInt, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list3, QList<int>() << 1 << 2 << 3); QList<int> list4 = QtConcurrent::blockingMappedReduced(QList<Number>(numberList), &Number::toInt, - &QList<int>::push_back, OrderedReduce); + push_back, OrderedReduce); QCOMPARE(list4, QList<int>() << 1 << 2 << 3); } @@ -1848,7 +1233,7 @@ void tst_QtConcurrentMap::blocking_mappedReduced() { QList<int> list2 = QtConcurrent::blockingMappedReduced(list, intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list2, QList<int>() << 1 << 4 << 9); @@ -1856,14 +1241,14 @@ void tst_QtConcurrentMap::blocking_mappedReduced() QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(), list.constEnd(), intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list3, QList<int>() << 1 << 4 << 9); QList<int> list4 = QtConcurrent::blockingMappedReduced(QList<int>(list), intSquare, - &QList<int>::push_back, + push_back, OrderedReduce); QCOMPARE(list, QList<int>() << 1 << 2 << 3); QCOMPARE(list4, QList<int>() << 1 << 4 << 9); @@ -1886,228 +1271,6 @@ void tst_QtConcurrentMap::blocking_mappedReduced() intSumReduce); QCOMPARE(sum3, 6); } - -#if QT_DEPRECATED_SINCE(5, 15) -QT_WARNING_PUSH -QT_WARNING_DISABLE_DEPRECATED - - QLinkedList<int> linkedList; - linkedList << 1 << 2 << 3; - QLinkedList<Number> numberLinkedList; - numberLinkedList << 1 << 2 << 3; - - // functor-functor - { - int sum = QtConcurrent::blockingMappedReduced<int>(linkedList, IntSquare(), IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::blockingMappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<int>(linkedList), IntSquare(), IntSumReduce()); - QCOMPARE(sum3, 14); - - int sum4 = QtConcurrent::blockingMappedReduced<int>(linkedList, intSquare, intSumReduce); - QCOMPARE(sum4, 14); - int sum5 = QtConcurrent::blockingMappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum5, 14); - - int sum6 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<int>(linkedList), - intSquare, - intSumReduce); - QCOMPARE(sum6, 14); - } - - // function-functor - { - int sum = QtConcurrent::blockingMappedReduced<int>(linkedList, intSquare, IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::blockingMappedReduced<int>(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<int>(linkedList), intSquare, IntSumReduce()); - QCOMPARE(sum3, 14); - } - - // functor-function - { - int sum = QtConcurrent::blockingMappedReduced(linkedList, IntSquare(), intSumReduce); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::blockingMappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - intSumReduce); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::blockingMappedReduced(QLinkedList<int>(linkedList), IntSquare(), intSumReduce); - QCOMPARE(sum3, 14); - } - - // function-function - { - int sum = QtConcurrent::blockingMappedReduced(linkedList, intSquare, intSumReduce); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::blockingMappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::blockingMappedReduced(QLinkedList<int>(linkedList), intSquare, intSumReduce); - QCOMPARE(sum3, 14); - } - - // functor-member - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMappedReduced(linkedList, - IntSquare(), - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - IntSquare(), - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMappedReduced(QLinkedList<int>(linkedList), - IntSquare(), - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 4 << 9); - } - - // member-functor - { - int sum = QtConcurrent::blockingMappedReduced<int>(numberLinkedList, &Number::toInt, IntSumReduce()); - QCOMPARE(sum, 6); - int sum2 = QtConcurrent::blockingMappedReduced<int>(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - IntSumReduce()); - QCOMPARE(sum2, 6); - - int sum3 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - IntSumReduce()); - QCOMPARE(sum3, 6); - } - - // member-member - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMappedReduced(numberLinkedList, - &Number::toInt, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 2 << 3); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMappedReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 2 << 3); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMappedReduced(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - &QLinkedList<int>::append, OrderedReduce); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 2 << 3); - } - - // function-member - { - QLinkedList<int> linkedList2 = QtConcurrent::blockingMappedReduced(linkedList, - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList2, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList3 = QtConcurrent::blockingMappedReduced(linkedList.constBegin(), - linkedList.constEnd(), - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList3, QLinkedList<int>() << 1 << 4 << 9); - - QLinkedList<int> linkedList4 = QtConcurrent::blockingMappedReduced(QLinkedList<int>(linkedList), - intSquare, - &QLinkedList<int>::append, - OrderedReduce); - QCOMPARE(linkedList, QLinkedList<int>() << 1 << 2 << 3); - QCOMPARE(linkedList4, QLinkedList<int>() << 1 << 4 << 9); - } - - // member-function - { - int sum = QtConcurrent::blockingMappedReduced(numberLinkedList, - &Number::toInt, - intSumReduce); - QCOMPARE(sum, 6); - int sum2 = QtConcurrent::blockingMappedReduced(numberLinkedList.constBegin(), - numberLinkedList.constEnd(), - &Number::toInt, - intSumReduce); - QCOMPARE(sum2, 6); - - int sum3 = QtConcurrent::blockingMappedReduced(QLinkedList<Number>(numberLinkedList), - &Number::toInt, - intSumReduce); - QCOMPARE(sum3, 6); - } - - // linked lists - { - - QLinkedList<int> list; - list << 1 << 2 << 3; - - QLinkedList<Number> numberList; - numberList << 1 << 2 << 3; - - int sum = QtConcurrent::blockingMappedReduced<int>(list, IntSquare(), IntSumReduce()); - QCOMPARE(sum, 14); - int sum2 = QtConcurrent::blockingMappedReduced<int>(list.constBegin(), - list.constEnd(), - IntSquare(), - IntSumReduce()); - QCOMPARE(sum2, 14); - - int sum3 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<int>(list), IntSquare(), IntSumReduce()); - QCOMPARE(sum3, 14); - - int sum4 = QtConcurrent::blockingMappedReduced<int>(list, intSquare, intSumReduce); - QCOMPARE(sum4, 14); - int sum5 = QtConcurrent::blockingMappedReduced<int>(list.constBegin(), - list.constEnd(), - intSquare, - intSumReduce); - QCOMPARE(sum5, 14); - - int sum6 = QtConcurrent::blockingMappedReduced<int>(QLinkedList<int>(list), - intSquare, - intSumReduce); - QCOMPARE(sum6, 14); - } - -QT_WARNING_POP -#endif - - // ### the same as above, with an initial result value } int sleeper(int val) @@ -2231,7 +1394,6 @@ public: }; Q_DECLARE_METATYPE(QVector<MemFnTester>); -Q_DECLARE_METATYPE(QList<MemFnTester>); void tst_QtConcurrentMap::functionOverloads() { @@ -2603,5 +1765,369 @@ void tst_QtConcurrentMap::persistentResultTest() QCOMPARE(ref.loadAcquire(), 3); } +void tst_QtConcurrentMap::mappedReducedInitialValue() +{ + // This is a copy of tst_QtConcurrentMap::mappedReduced with the initial value parameter added + + QList<int> list; + list << 1 << 2 << 3; + QList<Number> numberList; + numberList << 1 << 2 << 3; + + // test Q_DECLARE_OPERATORS_FOR_FLAGS + QtConcurrent::ReduceOptions opt = + (QtConcurrent::UnorderedReduce | QtConcurrent::SequentialReduce); + QVERIFY(opt); + + int initialValue = 10; + // functor-functor + { + int sum = QtConcurrent::mappedReduced<int>(list, IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::mappedReduced<int>( + list.constBegin(), list.constEnd(), IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::mappedReduced<int>( + QList<int>(list), IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum3, 24); + + int sum4 = QtConcurrent::mappedReduced<int>(list, intSquare, intSumReduce, initialValue); + QCOMPARE(sum4, 24); + int sum5 = QtConcurrent::mappedReduced<int>( + list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue); + QCOMPARE(sum5, 24); + + int sum6 = QtConcurrent::mappedReduced<int>( + QList<int>(list), intSquare, intSumReduce, initialValue); + QCOMPARE(sum6, 24); + } + + // function-functor + { + int sum = QtConcurrent::mappedReduced<int>(list, intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::mappedReduced<int>( + list.constBegin(), list.constEnd(), intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::mappedReduced<int>( + QList<int>(list), intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum3, 24); + } + + // functor-function + { + int sum = QtConcurrent::mappedReduced(list, IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::mappedReduced( + list.constBegin(), list.constEnd(), IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::mappedReduced( + QList<int>(list), IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum3, 24); + } + + // function-function + { + int sum = QtConcurrent::mappedReduced(list, intSquare, intSumReduce, initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::mappedReduced( + list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::mappedReduced( + QList<int>(list), intSquare, intSumReduce, initialValue); + QCOMPARE(sum3, 24); + } + + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); + + QVector<int> initialIntVector; + initialIntVector.push_back(10); + // functor-member + { + QList<int> list2 = QtConcurrent::mappedReduced( + list, IntSquare(), push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(), + list.constEnd(), + IntSquare(), + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list4 = QtConcurrent::mappedReduced( + QList<int>(list), IntSquare(), push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9); + } + + // member-functor + { + int sum = QtConcurrent::mappedReduced<int>( + numberList, &Number::toInt, IntSumReduce(), initialValue); + QCOMPARE(sum, 16); + int sum2 = QtConcurrent::mappedReduced<int>(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + IntSumReduce(), + initialValue); + QCOMPARE(sum2, 16); + + int sum3 = QtConcurrent::mappedReduced<int>( + QList<Number>(numberList), &Number::toInt, IntSumReduce(), initialValue); + QCOMPARE(sum3, 16); + } + + // member-member + { + QList<int> list2 = QtConcurrent::mappedReduced( + numberList, &Number::toInt, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 1 << 2 << 3); + + QList<int> list3 = QtConcurrent::mappedReduced(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list3, QList<int>() << 10 << 1 << 2 << 3); + + QList<int> list4 = QtConcurrent::mappedReduced(QList<Number>(numberList), + &Number::toInt, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list4, QList<int>() << 10 << 1 << 2 << 3); + } + + // function-member + { + QList<int> list2 = QtConcurrent::mappedReduced( + list, intSquare, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list3 = QtConcurrent::mappedReduced(list.constBegin(), + list.constEnd(), + intSquare, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list4 = QtConcurrent::mappedReduced( + QList<int>(list), intSquare, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9); + } + + // member-function + { + int sum = + QtConcurrent::mappedReduced(numberList, &Number::toInt, intSumReduce, initialValue); + QCOMPARE(sum, 16); + int sum2 = QtConcurrent::mappedReduced(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + intSumReduce, + initialValue); + QCOMPARE(sum2, 16); + + int sum3 = QtConcurrent::mappedReduced( + QList<Number>(numberList), &Number::toInt, intSumReduce, initialValue); + QCOMPARE(sum3, 16); + } +} + +void tst_QtConcurrentMap::blocking_mappedReducedInitialValue() +{ + // This is a copy of tst_QtConcurrentMap::blocking_mappedReduced with the initial value + // parameter added + + QList<int> list; + list << 1 << 2 << 3; + QList<Number> numberList; + numberList << 1 << 2 << 3; + + int initialValue = 10; + // functor-functor + { + int sum = QtConcurrent::blockingMappedReduced<int>( + list, IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::blockingMappedReduced<int>( + list.constBegin(), list.constEnd(), IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::blockingMappedReduced<int>( + QList<int>(list), IntSquare(), IntSumReduce(), initialValue); + QCOMPARE(sum3, 24); + + int sum4 = QtConcurrent::blockingMappedReduced<int>( + list, intSquare, intSumReduce, initialValue); + QCOMPARE(sum4, 24); + int sum5 = QtConcurrent::blockingMappedReduced<int>( + list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue); + QCOMPARE(sum5, 24); + + int sum6 = QtConcurrent::blockingMappedReduced<int>( + QList<int>(list), intSquare, intSumReduce, initialValue); + QCOMPARE(sum6, 24); + } + + // function-functor + { + int sum = QtConcurrent::blockingMappedReduced<int>( + list, intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::blockingMappedReduced<int>( + list.constBegin(), list.constEnd(), intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::blockingMappedReduced<int>( + QList<int>(list), intSquare, IntSumReduce(), initialValue); + QCOMPARE(sum3, 24); + } + + // functor-function + { + int sum = + QtConcurrent::blockingMappedReduced(list, IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::blockingMappedReduced( + list.constBegin(), list.constEnd(), IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::blockingMappedReduced( + QList<int>(list), IntSquare(), intSumReduce, initialValue); + QCOMPARE(sum3, 24); + } + + // function-function + { + int sum = QtConcurrent::blockingMappedReduced(list, intSquare, intSumReduce, initialValue); + QCOMPARE(sum, 24); + int sum2 = QtConcurrent::blockingMappedReduced( + list.constBegin(), list.constEnd(), intSquare, intSumReduce, initialValue); + QCOMPARE(sum2, 24); + + int sum3 = QtConcurrent::blockingMappedReduced( + QList<int>(list), intSquare, intSumReduce, initialValue); + QCOMPARE(sum3, 24); + } + + auto push_back = static_cast<void (QVector<int>::*)(const int &)>(&QVector<int>::push_back); + + QVector<int> initialIntVector; + initialIntVector.push_back(10); + // functor-member + { + QList<int> list2 = QtConcurrent::blockingMappedReduced( + list, IntSquare(), push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(), + list.constEnd(), + IntSquare(), + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list4 = QtConcurrent::blockingMappedReduced( + QList<int>(list), IntSquare(), push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9); + } + + // member-functor + { + int sum = QtConcurrent::blockingMappedReduced<int>( + numberList, &Number::toInt, IntSumReduce(), initialValue); + QCOMPARE(sum, 16); + int sum2 = QtConcurrent::blockingMappedReduced<int>(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + IntSumReduce(), + initialValue); + QCOMPARE(sum2, 16); + + int sum3 = QtConcurrent::blockingMappedReduced<int>( + QList<Number>(numberList), &Number::toInt, IntSumReduce(), initialValue); + QCOMPARE(sum3, 16); + } + + // member-member + { + QList<int> list2 = QtConcurrent::blockingMappedReduced( + numberList, &Number::toInt, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list2, QList<int>() << 10 << 1 << 2 << 3); + + QList<int> list3 = QtConcurrent::blockingMappedReduced(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list3, QList<int>() << 10 << 1 << 2 << 3); + + QList<int> list4 = QtConcurrent::blockingMappedReduced(QList<Number>(numberList), + &Number::toInt, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list4, QList<int>() << 10 << 1 << 2 << 3); + } + + // function-member + { + QList<int> list2 = QtConcurrent::blockingMappedReduced( + list, intSquare, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list2, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list3 = QtConcurrent::blockingMappedReduced(list.constBegin(), + list.constEnd(), + intSquare, + push_back, + initialIntVector, + OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list3, QList<int>() << 10 << 1 << 4 << 9); + + QList<int> list4 = QtConcurrent::blockingMappedReduced( + QList<int>(list), intSquare, push_back, initialIntVector, OrderedReduce); + QCOMPARE(list, QList<int>() << 1 << 2 << 3); + QCOMPARE(list4, QList<int>() << 10 << 1 << 4 << 9); + } + + // member-function + { + int sum = QtConcurrent::blockingMappedReduced( + numberList, &Number::toInt, intSumReduce, initialValue); + QCOMPARE(sum, 16); + int sum2 = QtConcurrent::blockingMappedReduced(numberList.constBegin(), + numberList.constEnd(), + &Number::toInt, + intSumReduce, + initialValue); + QCOMPARE(sum2, 16); + + int sum3 = QtConcurrent::blockingMappedReduced( + QList<Number>(numberList), &Number::toInt, intSumReduce, initialValue); + QCOMPARE(sum3, 16); + } +} + QTEST_MAIN(tst_QtConcurrentMap) #include "tst_qtconcurrentmap.moc" diff --git a/tests/auto/concurrent/qtconcurrentmedian/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentmedian/CMakeLists.txt new file mode 100644 index 0000000000..27b376a406 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentmedian/CMakeLists.txt @@ -0,0 +1,12 @@ +# Generated from qtconcurrentmedian.pro. + +##################################################################### +## tst_qtconcurrentmedian Test: +##################################################################### + +add_qt_test(tst_qtconcurrentmedian + SOURCES + tst_qtconcurrentmedian.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) diff --git a/tests/auto/concurrent/qtconcurrentmedian/qtconcurrentmedian.pro b/tests/auto/concurrent/qtconcurrentmedian/qtconcurrentmedian.pro index 0d07642028..59e22d24a1 100644 --- a/tests/auto/concurrent/qtconcurrentmedian/qtconcurrentmedian.pro +++ b/tests/auto/concurrent/qtconcurrentmedian/qtconcurrentmedian.pro @@ -2,4 +2,3 @@ CONFIG += testcase TARGET = tst_qtconcurrentmedian QT = core testlib concurrent SOURCES = tst_qtconcurrentmedian.cpp -DEFINES += QT_STRICT_ITERATORS diff --git a/tests/auto/concurrent/qtconcurrentrun/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentrun/CMakeLists.txt new file mode 100644 index 0000000000..ca1f616137 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentrun/CMakeLists.txt @@ -0,0 +1,15 @@ +# Generated from qtconcurrentrun.pro. + +##################################################################### +## tst_qtconcurrentrun Test: +##################################################################### + +add_qt_test(tst_qtconcurrentrun + SOURCES + tst_qtconcurrentrun.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) + +## Scopes: +##################################################################### diff --git a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp index a4eb2936b5..c0782d8483 100644 --- a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp +++ b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp @@ -50,6 +50,7 @@ private slots: #endif void functor(); void lambda(); + void callableObjectWithState(); }; void light() @@ -152,24 +153,24 @@ void tst_QtConcurrentRun::returnValue() QCOMPARE(f.result(), 10); A a; - f = run(&a, &A::member0); + f = run(&A::member0, &a); QCOMPARE(f.result(), 10); - f = run(&pool, &a, &A::member0); + f = run(&pool, &A::member0, &a); QCOMPARE(f.result(), 10); - f = run(&a, &A::member1, 20); + f = run(&A::member1, &a, 20); QCOMPARE(f.result(), 20); - f = run(&pool, &a, &A::member1, 20); + f = run(&pool, &A::member1, &a, 20); QCOMPARE(f.result(), 20); - f = run(a, &A::member0); + f = run(&A::member0, a); QCOMPARE(f.result(), 10); - f = run(&pool, a, &A::member0); + f = run(&pool, &A::member0, a); QCOMPARE(f.result(), 10); - f = run(a, &A::member1, 20); + f = run(&A::member1, a, 20); QCOMPARE(f.result(), 20); - f = run(&pool, a, &A::member1, 20); + f = run(&pool, &A::member1, a, 20); QCOMPARE(f.result(), 20); f = run(a); @@ -177,9 +178,9 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, a); QCOMPARE(f.result(), 10); - f = run(&a); + f = run(a); QCOMPARE(f.result(), 10); - f = run(&pool, &a); + f = run(&pool, std::ref(a)); QCOMPARE(f.result(), 10); f = run(a, 20); @@ -187,30 +188,30 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, a, 20); QCOMPARE(f.result(), 20); - f = run(&a, 20); + f = run(std::ref(a), 20); QCOMPARE(f.result(), 20); - f = run(&pool, &a, 20); + f = run(&pool, std::ref(a), 20); QCOMPARE(f.result(), 20); const AConst aConst = AConst(); - f = run(&aConst, &AConst::member0); + f = run(&AConst::member0, &aConst); QCOMPARE(f.result(), 10); - f = run(&pool, &aConst, &AConst::member0); + f = run(&pool, &AConst::member0, &aConst); QCOMPARE(f.result(), 10); - f = run(&aConst, &AConst::member1, 20); + f = run(&AConst::member1, &aConst, 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aConst, &AConst::member1, 20); + f = run(&pool, &AConst::member1, &aConst, 20); QCOMPARE(f.result(), 20); - f = run(aConst, &AConst::member0); + f = run(&AConst::member0, aConst); QCOMPARE(f.result(), 10); - f = run(&pool, aConst, &AConst::member0); + f = run(&pool, &AConst::member0, aConst); QCOMPARE(f.result(), 10); - f = run(aConst, &AConst::member1, 20); + f = run(&AConst::member1, aConst, 20); QCOMPARE(f.result(), 20); - f = run(&pool, aConst, &AConst::member1, 20); + f = run(&pool, &AConst::member1, aConst, 20); QCOMPARE(f.result(), 20); f = run(aConst); @@ -218,9 +219,9 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aConst); QCOMPARE(f.result(), 10); - f = run(&aConst); + f = run(std::ref(a)); QCOMPARE(f.result(), 10); - f = run(&pool, &aConst); + f = run(&pool, std::ref(a)); QCOMPARE(f.result(), 10); f = run(aConst, 20); @@ -228,30 +229,30 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aConst, 20); QCOMPARE(f.result(), 20); - f = run(&aConst, 20); + f = run(std::ref(aConst), 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aConst, 20); + f = run(&pool, std::ref(aConst), 20); QCOMPARE(f.result(), 20); ANoExcept aNoExcept; - f = run(&aNoExcept, &ANoExcept::member0); + f = run(&ANoExcept::member0, &aNoExcept); QCOMPARE(f.result(), 10); - f = run(&pool, &aNoExcept, &ANoExcept::member0); + f = run(&pool, &ANoExcept::member0, &aNoExcept); QCOMPARE(f.result(), 10); - f = run(&aNoExcept, &ANoExcept::member1, 20); + f = run(&ANoExcept::member1, &aNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aNoExcept, &ANoExcept::member1, 20); + f = run(&pool, &ANoExcept::member1, &aNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(aNoExcept, &ANoExcept::member0); + f = run(&ANoExcept::member0, aNoExcept); QCOMPARE(f.result(), 10); - f = run(&pool, aNoExcept, &ANoExcept::member0); + f = run(&pool, &ANoExcept::member0, aNoExcept); QCOMPARE(f.result(), 10); - f = run(aNoExcept, &ANoExcept::member1, 20); + f = run(&ANoExcept::member1, aNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&pool, aNoExcept, &ANoExcept::member1, 20); + f = run(&pool, &ANoExcept::member1, aNoExcept, 20); QCOMPARE(f.result(), 20); f = run(aNoExcept); @@ -259,9 +260,9 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aNoExcept); QCOMPARE(f.result(), 10); - f = run(&aNoExcept); + f = run(std::ref(aNoExcept)); QCOMPARE(f.result(), 10); - f = run(&pool, &aNoExcept); + f = run(&pool, std::ref(aNoExcept)); QCOMPARE(f.result(), 10); f = run(aNoExcept, 20); @@ -269,30 +270,30 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&aNoExcept, 20); + f = run(std::ref(aNoExcept), 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aNoExcept, 20); + f = run(&pool, std::ref(aNoExcept), 20); QCOMPARE(f.result(), 20); const AConstNoExcept aConstNoExcept = AConstNoExcept(); - f = run(&aConstNoExcept, &AConstNoExcept::member0); + f = run(&AConstNoExcept::member0, &aConstNoExcept); QCOMPARE(f.result(), 10); - f = run(&pool, &aConstNoExcept, &AConstNoExcept::member0); + f = run(&pool, &AConstNoExcept::member0, &aConstNoExcept); QCOMPARE(f.result(), 10); - f = run(&aConstNoExcept, &AConstNoExcept::member1, 20); + f = run(&AConstNoExcept::member1, &aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aConstNoExcept, &AConstNoExcept::member1, 20); + f = run(&pool, &AConstNoExcept::member1, &aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(aConstNoExcept, &AConstNoExcept::member0); + f = run(&AConstNoExcept::member0, aConstNoExcept); QCOMPARE(f.result(), 10); - f = run(&pool, aConstNoExcept, &AConstNoExcept::member0); + f = run(&pool, &AConstNoExcept::member0, aConstNoExcept); QCOMPARE(f.result(), 10); - f = run(aConstNoExcept, &AConstNoExcept::member1, 20); + f = run(&AConstNoExcept::member1, aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&pool, aConstNoExcept, &AConstNoExcept::member1, 20); + f = run(&pool, &AConstNoExcept::member1, aConstNoExcept, 20); QCOMPARE(f.result(), 20); f = run(aConstNoExcept); @@ -300,9 +301,9 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aConstNoExcept); QCOMPARE(f.result(), 10); - f = run(&aConstNoExcept); + f = run(std::ref(aConstNoExcept)); QCOMPARE(f.result(), 10); - f = run(&pool, &aConstNoExcept); + f = run(&pool, std::ref(aConstNoExcept)); QCOMPARE(f.result(), 10); f = run(aConstNoExcept, 20); @@ -310,9 +311,9 @@ void tst_QtConcurrentRun::returnValue() f = run(&pool, aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = run(&aConstNoExcept, 20); + f = run(std::ref(aConstNoExcept), 20); QCOMPARE(f.result(), 20); - f = run(&pool, &aConstNoExcept, 20); + f = run(&pool, std::ref(aConstNoExcept), 20); QCOMPARE(f.result(), 20); } @@ -341,25 +342,25 @@ void tst_QtConcurrentRun::functionObject() TestClass c; f = run(c); - f = run(&c); + f = run(std::ref(c)); f = run(c, 10); - f = run(&c, 10); + f = run(std::ref(c), 10); f = run(&pool, c); - f = run(&pool, &c); + f = run(&pool, std::ref(c)); f = run(&pool, c, 10); - f = run(&pool, &c, 10); + f = run(&pool, std::ref(c), 10); const TestConstClass cc = TestConstClass(); f = run(cc); - f = run(&cc); + f = run(std::ref(c)); f = run(cc, 10); - f = run(&cc, 10); + f = run(std::ref(c), 10); f = run(&pool, cc); - f = run(&pool, &cc); + f = run(&pool, std::ref(c)); f = run(&pool, cc, 10); - f = run(&pool, &cc, 10); + f = run(&pool, std::ref(c), 10); } @@ -369,26 +370,26 @@ void tst_QtConcurrentRun::memberFunctions() TestClass c; - run(c, &TestClass::foo).waitForFinished(); - run(&c, &TestClass::foo).waitForFinished(); - run(c, &TestClass::fooInt, 10).waitForFinished(); - run(&c, &TestClass::fooInt, 10).waitForFinished(); + run(&TestClass::foo, c).waitForFinished(); + run(&TestClass::foo, &c).waitForFinished(); + run(&TestClass::fooInt, c, 10).waitForFinished(); + run(&TestClass::fooInt, &c, 10).waitForFinished(); - run(&pool, c, &TestClass::foo).waitForFinished(); - run(&pool, &c, &TestClass::foo).waitForFinished(); - run(&pool, c, &TestClass::fooInt, 10).waitForFinished(); - run(&pool, &c, &TestClass::fooInt, 10).waitForFinished(); + run(&pool, &TestClass::foo, c).waitForFinished(); + run(&pool, &TestClass::foo, &c).waitForFinished(); + run(&pool, &TestClass::fooInt, c, 10).waitForFinished(); + run(&pool, &TestClass::fooInt, &c, 10).waitForFinished(); const TestConstClass cc = TestConstClass(); - run(cc, &TestConstClass::foo).waitForFinished(); - run(&cc, &TestConstClass::foo).waitForFinished(); - run(cc, &TestConstClass::fooInt, 10).waitForFinished(); - run(&cc, &TestConstClass::fooInt, 10).waitForFinished(); + run(&TestConstClass::foo, cc).waitForFinished(); + run(&TestConstClass::foo, &cc).waitForFinished(); + run(&TestConstClass::fooInt, cc, 10).waitForFinished(); + run(&TestConstClass::fooInt, &cc, 10).waitForFinished(); - run(&pool, cc, &TestConstClass::foo).waitForFinished(); - run(&pool, &cc, &TestConstClass::foo).waitForFinished(); - run(&pool, cc, &TestConstClass::fooInt, 10).waitForFinished(); - run(&pool, &cc, &TestConstClass::fooInt, 10).waitForFinished(); + run(&pool, &TestConstClass::foo, cc).waitForFinished(); + run(&pool, &TestConstClass::foo, &cc).waitForFinished(); + run(&pool, &TestConstClass::fooInt, cc, 10).waitForFinished(); + run(&pool, &TestConstClass::fooInt, &cc, 10).waitForFinished(); } @@ -437,8 +438,8 @@ void tst_QtConcurrentRun::implicitConvertibleTypes() run(stringConstRefFunction, QLatin1String("Foo")).waitForFinished(); run(&pool, stringConstRefFunction, QLatin1String("Foo")).waitForFinished(); QString string; - run(stringRefFunction, string).waitForFinished(); - run(&pool, stringRefFunction, string).waitForFinished(); + run(stringRefFunction, std::ref(string)).waitForFinished(); + run(&pool, stringRefFunction, std::ref(string)).waitForFinished(); } void fn() { } @@ -732,5 +733,34 @@ void tst_QtConcurrentRun::lambda() } } +struct CallableWithState +{ + void setNewState(int newState) { state = newState; } + int operator()(int newState) { return (state = newState); } + + static constexpr int defaultState() { return 42; } + int state = defaultState(); +}; + +void tst_QtConcurrentRun::callableObjectWithState() +{ + CallableWithState o; + + // Run method setNewState explicitly + run(&CallableWithState::setNewState, &o, CallableWithState::defaultState() + 1).waitForFinished(); + QCOMPARE(o.state, CallableWithState::defaultState() + 1); + + // Run operator()(int) explicitly + run(std::ref(o), CallableWithState::defaultState() + 2).waitForFinished(); + QCOMPARE(o.state, CallableWithState::defaultState() + 2); + + // Run on a copy of object (original object remains unchanged) + run(o, CallableWithState::defaultState() + 3).waitForFinished(); + QCOMPARE(o.state, CallableWithState::defaultState() + 2); + + // Explicitly run on a temporary object + QCOMPARE(run(CallableWithState(), 15).result(), 15); +} + QTEST_MAIN(tst_QtConcurrentRun) #include "tst_qtconcurrentrun.moc" diff --git a/tests/auto/concurrent/qtconcurrenttask/CMakeLists.txt b/tests/auto/concurrent/qtconcurrenttask/CMakeLists.txt new file mode 100644 index 0000000000..3e6fc9fe6c --- /dev/null +++ b/tests/auto/concurrent/qtconcurrenttask/CMakeLists.txt @@ -0,0 +1,12 @@ +# Generated from qtconcurrenttask.pro. + +##################################################################### +## tst_qtconcurrenttask Test: +##################################################################### + +add_qt_test(tst_qtconcurrenttask + SOURCES + tst_qtconcurrenttask.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) diff --git a/tests/auto/concurrent/qtconcurrenttask/qtconcurrenttask.pro b/tests/auto/concurrent/qtconcurrenttask/qtconcurrenttask.pro new file mode 100644 index 0000000000..4404efa0b3 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrenttask/qtconcurrenttask.pro @@ -0,0 +1,4 @@ +CONFIG += testcase +TARGET = tst_qtconcurrenttask +QT = core testlib concurrent +SOURCES = tst_qtconcurrenttask.cpp diff --git a/tests/auto/concurrent/qtconcurrenttask/tst_qtconcurrenttask.cpp b/tests/auto/concurrent/qtconcurrenttask/tst_qtconcurrenttask.cpp new file mode 100644 index 0000000000..0d08efa463 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrenttask/tst_qtconcurrenttask.cpp @@ -0,0 +1,160 @@ +/**************************************************************************** +** +** Copyright (C) 2020 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$ +** +****************************************************************************/ + +#include <qtconcurrenttask.h> + +#include <QtTest/QtTest> + +class tst_QtConcurrentTask : public QObject +{ + Q_OBJECT + +private Q_SLOTS: + void taskWithFreeFunction(); + void taskWithClassMethod(); + void taskWithCallableObject(); + void taskWithLambda(); + void taskWithArguments(); + void useCustomThreadPool(); + void setPriority(); + void adjustAllSettings(); +}; + +using namespace QtConcurrent; + +void tst_QtConcurrentTask::taskWithFreeFunction() +{ + QVariant value(42); + + auto result = task(&qvariant_cast<int>) + .withArguments(value) + .spawn() + .result(); + + QCOMPARE(result, 42); +} +void tst_QtConcurrentTask::taskWithClassMethod() +{ + QString result("foobar"); + + task(&QString::chop).withArguments(&result, 3).spawn().waitForFinished(); + + QCOMPARE(result, "foo"); +} +void tst_QtConcurrentTask::taskWithCallableObject() +{ + QCOMPARE(task(std::plus<int>()) + .withArguments(40, 2) + .spawn() + .result(), + 42); +} + +void tst_QtConcurrentTask::taskWithLambda() +{ + QCOMPARE(task([]{ return 42; }).spawn().result(), 42); +} + +void tst_QtConcurrentTask::taskWithArguments() +{ + auto result = task([](int arg1, int arg2){ return arg1 + arg2; }) + .withArguments(40, 2) + .spawn() + .result(); + QCOMPARE(result, 42); +} + +void tst_QtConcurrentTask::useCustomThreadPool() +{ + QThreadPool pool; + + int result = 0; + task([&]{ result = 42; }).onThreadPool(pool).spawn().waitForFinished(); + + QCOMPARE(result, 42); +} + +void tst_QtConcurrentTask::setPriority() +{ + QThreadPool pool; + pool.setMaxThreadCount(1); + + QSemaphore sem; + + QVector<QFuture<void>> futureResults; + futureResults << task([&]{ sem.acquire(); }) + .onThreadPool(pool) + .spawn(); + + const int tasksCount = 10; + QVector<int> priorities(tasksCount); + std::iota(priorities.begin(), priorities.end(), 1); + auto seed = std::chrono::system_clock::now().time_since_epoch().count(); + std::shuffle(priorities.begin(), priorities.end(), std::default_random_engine(seed)); + + QVector<int> actual; + for (int priority : priorities) + futureResults << task([priority, &actual] { actual << priority; }) + .onThreadPool(pool) + .withPriority(priority) + .spawn(); + + sem.release(); + pool.waitForDone(); + + for (const auto &f : futureResults) + QVERIFY(f.isFinished()); + + QVector<int> expected(priorities); + std::sort(expected.begin(), expected.end(), std::greater<>()); + + QCOMPARE(actual, expected); +} + +void tst_QtConcurrentTask::adjustAllSettings() +{ + QThreadPool pool; + pool.setMaxThreadCount(1); + + const int priority = 10; + + QVector<int> result; + auto append = [&](auto &&...args){ (result << ... << args); }; + + task(std::move(append)) + .withArguments(1, 2, 3) + .onThreadPool(pool) + .withPriority(priority) + .spawn() + .waitForFinished(); + + QCOMPARE(result, QVector<int>({1, 2, 3})); +} + +QTEST_MAIN(tst_QtConcurrentTask) +#include "tst_qtconcurrenttask.moc" diff --git a/tests/auto/concurrent/qtconcurrentthreadengine/CMakeLists.txt b/tests/auto/concurrent/qtconcurrentthreadengine/CMakeLists.txt new file mode 100644 index 0000000000..e9384c4fb4 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentthreadengine/CMakeLists.txt @@ -0,0 +1,12 @@ +# Generated from qtconcurrentthreadengine.pro. + +##################################################################### +## tst_qtconcurrentthreadengine Test: +##################################################################### + +add_qt_test(tst_qtconcurrentthreadengine + SOURCES + tst_qtconcurrentthreadengine.cpp + PUBLIC_LIBRARIES + Qt::Concurrent +) |