From a245945f29621ce9011f4c82f23076d2a28b5aa9 Mon Sep 17 00:00:00 2001 From: Jarek Kobus Date: Mon, 27 Apr 2020 14:51:00 +0200 Subject: [PATCH] Add more tests for QtConcurrent::filterReduced() Test the case where reduce function of the form: V function(T &result, const U &intermediate) has T and U types different. Task-number: QTBUG-83802 Change-Id: Ic89396caba16e7e47ae3ec1527e31b8620f1b08c Reviewed-by: Sona Kurazyan --- .../tst_qtconcurrentfilter.cpp | 101 ++++++++++++++++++ .../concurrent/qtconcurrentmap/functions.h | 14 +++ 2 files changed, 115 insertions(+) diff --git a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp index da8647bbcc0..6e01542a577 100644 --- a/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp +++ b/tests/auto/concurrent/qtconcurrentfilter/tst_qtconcurrentfilter.cpp @@ -40,7 +40,9 @@ private slots: void filter(); void filtered(); void filteredReduced(); + void filteredReducedDifferentType(); void filteredReducedInitialValue(); + void filteredReducedDifferentTypeInitialValue(); void resultAt(); void incrementalResults(); void noDetach(); @@ -275,6 +277,55 @@ void tst_QtConcurrentFilter::filteredReduced() CHECK_FAIL("lambda-lambda"); } +void tst_QtConcurrentFilter::filteredReducedDifferentType() +{ + const QList numberList {1, 2, 3, 4}; + const int sum = 6; // sum of even values + + auto lambdaIsEven = [](const Number &x) { + return (x.toInt() & 1) == 0; + }; + auto lambdaSumReduce = [](int &sum, const Number &x) { + sum += x.toInt(); + }; + + // Test the case where reduce function of the form: + // V function(T &result, const U &intermediate) + // has T and U types different. + + // FUNCTOR-other + testFilteredReduced(numberList, sum, KeepEvenNumbers(), NumberSumReduce()); + CHECK_FAIL("functor-functor"); + testFilteredReduced(numberList, sum, KeepEvenNumbers(), numberSumReduce); + CHECK_FAIL("functor-function"); + testFilteredReduced(numberList, sum, KeepEvenNumbers(), lambdaSumReduce); + CHECK_FAIL("functor-lambda"); + + // FUNCTION-other + testFilteredReduced(numberList, sum, keepEvenNumbers, NumberSumReduce()); + CHECK_FAIL("function-functor"); + testFilteredReduced(numberList, sum, keepEvenNumbers, numberSumReduce); + CHECK_FAIL("function-function"); + testFilteredReduced(numberList, sum, keepEvenNumbers, lambdaSumReduce); + CHECK_FAIL("function-lambda"); + + // MEMBER-other + testFilteredReduced(numberList, sum, &Number::isEven, NumberSumReduce()); + CHECK_FAIL("member-functor"); + testFilteredReduced(numberList, sum, &Number::isEven, numberSumReduce); + CHECK_FAIL("member-function"); + testFilteredReduced(numberList, sum, &Number::isEven, lambdaSumReduce); + CHECK_FAIL("member-lambda"); + + // LAMBDA-other + testFilteredReduced(numberList, sum, lambdaIsEven, NumberSumReduce()); + CHECK_FAIL("lambda-functor"); + testFilteredReduced(numberList, sum, lambdaIsEven, numberSumReduce); + CHECK_FAIL("lambda-function"); + testFilteredReduced(numberList, sum, lambdaIsEven, lambdaSumReduce); + CHECK_FAIL("lambda-lambda"); +} + template numberList {1, 2, 3, 4}; + const int initial = 10; + const int sum = 16; // sum of even values and initial value + + auto lambdaIsEven = [](const Number &x) { + return (x.toInt() & 1) == 0; + }; + auto lambdaSumReduce = [](int &sum, const Number &x) { + sum += x.toInt(); + }; + + // Test the case where reduce function of the form: + // V function(T &result, const U &intermediate) + // has T and U types different. + + // FUNCTOR-other + testFilteredReducedInitialValue(numberList, sum, KeepEvenNumbers(), NumberSumReduce(), initial); + CHECK_FAIL("functor-functor"); + testFilteredReducedInitialValue(numberList, sum, KeepEvenNumbers(), numberSumReduce, initial); + CHECK_FAIL("functor-function"); + testFilteredReducedInitialValue(numberList, sum, KeepEvenNumbers(), lambdaSumReduce, initial); + CHECK_FAIL("functor-lambda"); + + // FUNCTION-other + testFilteredReducedInitialValue(numberList, sum, keepEvenNumbers, NumberSumReduce(), initial); + CHECK_FAIL("function-functor"); + testFilteredReducedInitialValue(numberList, sum, keepEvenNumbers, numberSumReduce, initial); + CHECK_FAIL("function-function"); + testFilteredReducedInitialValue(numberList, sum, keepEvenNumbers, lambdaSumReduce, initial); + CHECK_FAIL("function-lambda"); + + // MEMBER-other + testFilteredReducedInitialValue(numberList, sum, &Number::isEven, NumberSumReduce(), initial); + CHECK_FAIL("member-functor"); + testFilteredReducedInitialValue(numberList, sum, &Number::isEven, numberSumReduce, initial); + CHECK_FAIL("member-function"); + testFilteredReducedInitialValue(numberList, sum, &Number::isEven, lambdaSumReduce, initial); + CHECK_FAIL("member-lambda"); + + // LAMBDA-other + testFilteredReducedInitialValue(numberList, sum, lambdaIsEven, NumberSumReduce(), initial); + CHECK_FAIL("lambda-functor"); + testFilteredReducedInitialValue(numberList, sum, lambdaIsEven, numberSumReduce, initial); + CHECK_FAIL("lambda-function"); + testFilteredReducedInitialValue(numberList, sum, lambdaIsEven, lambdaSumReduce, initial); + CHECK_FAIL("lambda-lambda"); +} + bool filterfn(int i) { return (i % 2); diff --git a/tests/auto/concurrent/qtconcurrentmap/functions.h b/tests/auto/concurrent/qtconcurrentmap/functions.h index 838b7090d8e..b37ea08716c 100644 --- a/tests/auto/concurrent/qtconcurrentmap/functions.h +++ b/tests/auto/concurrent/qtconcurrentmap/functions.h @@ -91,6 +91,20 @@ public: } }; +bool keepEvenNumbers(const Number &x) +{ + return (x.toInt() & 1) == 0; +} + +class KeepEvenNumbers +{ +public: + bool operator()(const Number &x) + { + return (x.toInt() & 1) == 0; + } +}; + void intSumReduce(int &sum, int x) { sum += x;