diff options
Diffstat (limited to 'tests/auto/concurrent/qtconcurrentfiltermapgenerated/tst_qtconcurrent_selected_tests.cpp')
-rw-r--r-- | tests/auto/concurrent/qtconcurrentfiltermapgenerated/tst_qtconcurrent_selected_tests.cpp | 347 |
1 files changed, 347 insertions, 0 deletions
diff --git a/tests/auto/concurrent/qtconcurrentfiltermapgenerated/tst_qtconcurrent_selected_tests.cpp b/tests/auto/concurrent/qtconcurrentfiltermapgenerated/tst_qtconcurrent_selected_tests.cpp new file mode 100644 index 0000000000..edb7cce4c9 --- /dev/null +++ b/tests/auto/concurrent/qtconcurrentfiltermapgenerated/tst_qtconcurrent_selected_tests.cpp @@ -0,0 +1,347 @@ +// Copyright (C) 2020 The Qt Company Ltd. +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only + +#include "tst_qtconcurrentfiltermapgenerated.h" + +void tst_QtConcurrentFilterMapGenerated::mapReduceThroughDifferentTypes() +{ + /* test for + template<typename typename ResultType, typename Iterator, typename MapFunctor, typename + ReduceFunctor, typename reductionitemtype> ResultType blockingMappedReduced(Iterator begin, + Iterator end, MapFunctor function, ReduceFunctor reduceFunction, reductionitemtype && + initialValue, ReduceOptions); + + with + inputsequence=standard + inputitemtype=standard + maptype=different + mappeditemtype=standard + reductiontype=different + reductionitemtype=standard + mapfunction=function + mapfunctionpassing=lvalue + reductionfunction=function + reductionfunctionpassing=lvalue + reductioninitialvaluepassing=lvalue + reductionoptions=unspecified + */ + + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + auto map = myMap<SequenceItem<tag_input>, SequenceItem<tag_mapped>>; + auto reductor = myReduce<SequenceItem<tag_mapped>, SequenceItem<tag_reduction>>; + auto initialvalue = SequenceItem<tag_reduction>(0, true); + + auto result = QtConcurrent::blockingMappedReduced(input_sequence.begin(), input_sequence.end(), + map, reductor, initialvalue); + + auto expected_result = SequenceItem<tag_reduction>(42, true); + QCOMPARE(result, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::moveOnlyFilterObject() +{ + /* test for + template<typename Sequence, typename KeepFunctor> + void blockingFilter(QThreadPool* pool, Sequence & sequence, KeepFunctor filterFunction); + + with + inputsequence=standard + inputitemtype=standard + filterfunction=moveonlyfunctor + filterfunctionpassing=rvalue + */ + + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + QtConcurrent::blockingFilter(&pool, input_sequence, + MyMoveOnlyFilter<SequenceItem<tag_input>> {}); + + auto expected_result = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + return result; + }(); + + QCOMPARE(input_sequence, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::moveOnlyMapObject() +{ + /* test for + template<typename Sequence, typename MapFunctor> + void blockingMap(QThreadPool* pool, Sequence & sequence, MapFunctor function); + + with + inputsequence=standard + inputitemtype=standard + mapfunction=moveonlyfunctor + mapfunctionpassing=rvalue + */ + + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + QtConcurrent::blockingMap(&pool, input_sequence, + MyMoveOnlyInplaceMap<SequenceItem<tag_input>> {}); + + auto expected_result = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + result.push_back(SequenceItem<tag_input>(8, true)); + result.push_back(SequenceItem<tag_input>(10, true)); + result.push_back(SequenceItem<tag_input>(12, true)); + return result; + }(); + + QCOMPARE(input_sequence, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::moveOnlyReduceObject() +{ + /* test for + template<typename typename ResultType, typename Sequence, typename MapFunctor, typename + ReduceFunctor> ResultType blockingMappedReduced(QThreadPool* pool, const Sequence & sequence, + MapFunctor function, ReduceFunctor reduceFunction, ReduceOptions); + + with + inputsequence=standard + inputsequencepassing=lvalue + inputitemtype=standard + maptype=same + mappeditemtype=standard + reductiontype=same + reductionitemtype=standard + mapfunction=functor + mapfunctionpassing=lvalue + reductionfunction=moveonlyfunctor + reductionfunctionpassing=rvalue + reductionoptions=unspecified + */ + + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + auto map = MyMap<SequenceItem<tag_input>, SequenceItem<tag_input>> {}; + + auto result = QtConcurrent::blockingMappedReduced<SequenceItem<tag_input>>( + &pool, input_sequence, map, + MyMoveOnlyReduce<SequenceItem<tag_input>, SequenceItem<tag_input>> {}); + + auto expected_result = SequenceItem<tag_input>(42, true); + + QCOMPARE(result, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::functorAsReduction() +{ + /* test for + template<typename typename ResultType, typename Sequence, typename KeepFunctor, typename + ReduceFunctor, typename reductionitemtype> ResultType blockingFilteredReduced(QThreadPool* pool, + const Sequence & sequence, KeepFunctor filterFunction, ReduceFunctor reduceFunction, + reductionitemtype && initialValue, ReduceOptions); + + with + inputsequence=standard + inputsequencepassing=lvalue + inputitemtype=standard + reductiontype=same + reductionitemtype=standard + filterfunction=functor + filterfunctionpassing=lvalue + reductionfunction=functor + reductionfunctionpassing=lvalue + reductioninitialvaluepassing=lvalue + reductionoptions=unspecified + */ + + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + auto filter = MyFilter<SequenceItem<tag_input>> {}; + + auto reductor = MyReduce<SequenceItem<tag_input>, SequenceItem<tag_input>> {}; + auto initialvalue = SequenceItem<tag_input>(0, true); + + auto result = QtConcurrent::blockingFilteredReduced<SequenceItem<tag_input>>( + &pool, input_sequence, filter, reductor, initialvalue); + + auto expected_result = SequenceItem<tag_input>(9, true); + + QCOMPARE(result, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::moveOnlyReductionItem() +{ + /* test for + template<typename typename ResultType, typename Sequence, typename KeepFunctor, typename + ReduceFunctor, typename reductionitemtype> ResultType blockingFilteredReduced(QThreadPool* pool, + const Sequence & sequence, KeepFunctor filterFunction, ReduceFunctor reduceFunction, + reductionitemtype && initialValue, ReduceOptions); + + with + inputsequence=standard + inputsequencepassing=lvalue + inputitemtype=standard + reductiontype=different + reductionitemtype=moveonly + filterfunction=moveonlyfunctor + filterfunctionpassing=rvalue + reductionfunction=function + reductionfunctionpassing=lvalue + reductioninitialvaluepassing=rvalue + reductionoptions=unspecified + */ +/* TODO: does not work yet + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + auto reductor = myReduce<SequenceItem<tag_input>, MoveOnlySequenceItem<tag_reduction>>; + + auto result = QtConcurrent::blockingFilteredReduced( + &pool, input_sequence, MyMoveOnlyFilter<SequenceItem<tag_input>> {}, reductor, + MoveOnlySequenceItem<tag_reduction>(0, true)); + + auto expected_result = MoveOnlySequenceItem<tag_reduction>(9, true); + + QCOMPARE(result, expected_result);*/ +} + +void tst_QtConcurrentFilterMapGenerated::noDefaultConstructorItemMapped() +{ + /* test for + template<typename typename ResultType, typename Sequence, typename MapFunctor, typename + ReduceFunctor, typename reductionitemtype> ResultType blockingMappedReduced(QThreadPool* pool, + const Sequence & sequence, MapFunctor function, ReduceFunctor reduceFunction, reductionitemtype + && initialValue, ReduceOptions); + + with + inputsequence=standard + inputsequencepassing=lvalue + inputitemtype=standard + maptype=same + mappeditemtype=standard + reductiontype=different + reductionitemtype=noconstruct + mapfunction=functor + mapfunctionpassing=lvalue + reductionfunction=function + reductionfunctionpassing=lvalue + reductioninitialvaluepassing=lvalue + reductionoptions=unspecified + */ + + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + auto map = MyMap<SequenceItem<tag_input>, SequenceItem<tag_input>> {}; + auto reductor = myReduce<SequenceItem<tag_input>, NoConstructSequenceItem<tag_reduction>>; + auto initialvalue = NoConstructSequenceItem<tag_reduction>(0, true); + + auto result = + QtConcurrent::blockingMappedReduced(&pool, input_sequence, map, reductor, initialvalue); + + auto expected_result = NoConstructSequenceItem<tag_reduction>(42, true); + + QCOMPARE(result, expected_result); +} + +void tst_QtConcurrentFilterMapGenerated::noDefaultConstructorItemFiltered() +{ + QThreadPool pool; + pool.setMaxThreadCount(1); + auto input_sequence = []() { + std::vector<SequenceItem<tag_input>> result; + result.push_back(SequenceItem<tag_input>(1, true)); + result.push_back(SequenceItem<tag_input>(2, true)); + result.push_back(SequenceItem<tag_input>(3, true)); + result.push_back(SequenceItem<tag_input>(4, true)); + result.push_back(SequenceItem<tag_input>(5, true)); + result.push_back(SequenceItem<tag_input>(6, true)); + return result; + }(); + + auto filter = MyFilter<SequenceItem<tag_input>> {}; + auto reductor = myReduce<SequenceItem<tag_input>, NoConstructSequenceItem<tag_reduction>>; + auto initialvalue = NoConstructSequenceItem<tag_reduction>(0, true); + + auto result = QtConcurrent::blockingFilteredReduced(&pool, input_sequence, filter, reductor, + initialvalue); + + auto expected_result = NoConstructSequenceItem<tag_reduction>(9, true); + + QCOMPARE(result, expected_result); +} |