From cf043a785ac9357e8f1283ea9e1496261af2b1a5 Mon Sep 17 00:00:00 2001 From: Jarek Kobus Date: Fri, 2 Oct 2020 19:24:38 +0200 Subject: QtConcurrent: Integrate runWithPromise into run Change-Id: I6eb95aa66ff847e8bb9aac348fded3a5d55015b6 Reviewed-by: Paul Wicking Reviewed-by: Sona Kurazyan --- .../qtconcurrentrun/tst_qtconcurrentrun.cpp | 376 ++++++++++++--------- 1 file changed, 217 insertions(+), 159 deletions(-) (limited to 'tests/auto/concurrent') diff --git a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp index ae1edb54a5..1132954a82 100644 --- a/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp +++ b/tests/auto/concurrent/qtconcurrentrun/tst_qtconcurrentrun.cpp @@ -57,6 +57,7 @@ private slots: void withPromiseInThreadPool(); void moveOnlyType(); void crefFunction(); + void customPromise(); }; void light() @@ -122,14 +123,14 @@ void tst_QtConcurrentRun::runLightFunction() void (*f3)(QPromise &) = lightOverloaded; qDebug("starting function with promise"); - QFuture future3 = runWithPromise(f3); + QFuture future3 = run(f3); qDebug("waiting"); future3.waitForFinished(); qDebug("done"); void (*f4)(QPromise &, int v) = lightOverloaded; qDebug("starting function with promise and with arg"); - QFuture future4 = runWithPromise(f4, 2); + QFuture future4 = run(f4, 2); qDebug("waiting"); future4.waitForFinished(); qDebug("done"); @@ -429,141 +430,141 @@ void tst_QtConcurrentRun::reportValueWithPromise() QThreadPool pool; QFuture f; - f = runWithPromise(reportInt0); + f = run(reportInt0); QCOMPARE(f.result(), 0); - f = runWithPromise(&pool, reportInt0); + f = run(&pool, reportInt0); QCOMPARE(f.result(), 0); - f = runWithPromise(reportIntPlusOne, 5); + f = run(reportIntPlusOne, 5); QCOMPARE(f.result(), 6); - f = runWithPromise(&pool, reportIntPlusOne, 5); + f = run(&pool, reportIntPlusOne, 5); QCOMPARE(f.result(), 6); AWithPromise a; - f = runWithPromise(&AWithPromise::member0, &a); + f = run(&AWithPromise::member0, &a); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AWithPromise::member0, &a); + f = run(&pool, &AWithPromise::member0, &a); QCOMPARE(f.result(), 10); - f = runWithPromise(&AWithPromise::member1, &a, 20); + f = run(&AWithPromise::member1, &a, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AWithPromise::member1, &a, 20); + f = run(&pool, &AWithPromise::member1, &a, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&AWithPromise::member0, a); + f = run(&AWithPromise::member0, a); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AWithPromise::member0, a); + f = run(&pool, &AWithPromise::member0, a); QCOMPARE(f.result(), 10); - f = runWithPromise(&AWithPromise::member1, a, 20); + f = run(&AWithPromise::member1, a, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AWithPromise::member1, a, 20); + f = run(&pool, &AWithPromise::member1, a, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(a); + f = run(a); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, a); + f = run(&pool, a); QCOMPARE(f.result(), 10); - f = runWithPromise(std::ref(a)); + f = run(std::ref(a)); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, std::ref(a)); + f = run(&pool, std::ref(a)); QCOMPARE(f.result(), 10); const AConstWithPromise aConst = AConstWithPromise(); - f = runWithPromise(&AConstWithPromise::member0, &aConst); + f = run(&AConstWithPromise::member0, &aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AConstWithPromise::member0, &aConst); + f = run(&pool, &AConstWithPromise::member0, &aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(&AConstWithPromise::member1, &aConst, 20); + f = run(&AConstWithPromise::member1, &aConst, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AConstWithPromise::member1, &aConst, 20); + f = run(&pool, &AConstWithPromise::member1, &aConst, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&AConstWithPromise::member0, aConst); + f = run(&AConstWithPromise::member0, aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AConstWithPromise::member0, aConst); + f = run(&pool, &AConstWithPromise::member0, aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(&AConstWithPromise::member1, aConst, 20); + f = run(&AConstWithPromise::member1, aConst, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AConstWithPromise::member1, aConst, 20); + f = run(&pool, &AConstWithPromise::member1, aConst, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(aConst); + f = run(aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, aConst); + f = run(&pool, aConst); QCOMPARE(f.result(), 10); - f = runWithPromise(std::ref(a)); + f = run(std::ref(a)); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, std::ref(a)); + f = run(&pool, std::ref(a)); QCOMPARE(f.result(), 10); ANoExceptWithPromise aNoExcept; - f = runWithPromise(&ANoExceptWithPromise::member0, &aNoExcept); + f = run(&ANoExceptWithPromise::member0, &aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &ANoExceptWithPromise::member0, &aNoExcept); + f = run(&pool, &ANoExceptWithPromise::member0, &aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&ANoExceptWithPromise::member1, &aNoExcept, 20); + f = run(&ANoExceptWithPromise::member1, &aNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &ANoExceptWithPromise::member1, &aNoExcept, 20); + f = run(&pool, &ANoExceptWithPromise::member1, &aNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&ANoExceptWithPromise::member0, aNoExcept); + f = run(&ANoExceptWithPromise::member0, aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &ANoExceptWithPromise::member0, aNoExcept); + f = run(&pool, &ANoExceptWithPromise::member0, aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&ANoExceptWithPromise::member1, aNoExcept, 20); + f = run(&ANoExceptWithPromise::member1, aNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &ANoExceptWithPromise::member1, aNoExcept, 20); + f = run(&pool, &ANoExceptWithPromise::member1, aNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(aNoExcept); + f = run(aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, aNoExcept); + f = run(&pool, aNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(std::ref(aNoExcept)); + f = run(std::ref(aNoExcept)); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, std::ref(aNoExcept)); + f = run(&pool, std::ref(aNoExcept)); QCOMPARE(f.result(), 10); const AConstNoExceptWithPromise aConstNoExcept = AConstNoExceptWithPromise(); - f = runWithPromise(&AConstNoExceptWithPromise::member0, &aConstNoExcept); + f = run(&AConstNoExceptWithPromise::member0, &aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AConstNoExceptWithPromise::member0, &aConstNoExcept); + f = run(&pool, &AConstNoExceptWithPromise::member0, &aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&AConstNoExceptWithPromise::member1, &aConstNoExcept, 20); + f = run(&AConstNoExceptWithPromise::member1, &aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AConstNoExceptWithPromise::member1, &aConstNoExcept, 20); + f = run(&pool, &AConstNoExceptWithPromise::member1, &aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&AConstNoExceptWithPromise::member0, aConstNoExcept); + f = run(&AConstNoExceptWithPromise::member0, aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, &AConstNoExceptWithPromise::member0, aConstNoExcept); + f = run(&pool, &AConstNoExceptWithPromise::member0, aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&AConstNoExceptWithPromise::member1, aConstNoExcept, 20); + f = run(&AConstNoExceptWithPromise::member1, aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(&pool, &AConstNoExceptWithPromise::member1, aConstNoExcept, 20); + f = run(&pool, &AConstNoExceptWithPromise::member1, aConstNoExcept, 20); QCOMPARE(f.result(), 20); - f = runWithPromise(aConstNoExcept); + f = run(aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, aConstNoExcept); + f = run(&pool, aConstNoExcept); QCOMPARE(f.result(), 10); - f = runWithPromise(std::ref(aConstNoExcept)); + f = run(std::ref(aConstNoExcept)); QCOMPARE(f.result(), 10); - f = runWithPromise(&pool, std::ref(aConstNoExcept)); + f = run(&pool, std::ref(aConstNoExcept)); QCOMPARE(f.result(), 10); } @@ -960,14 +961,14 @@ void tst_QtConcurrentRun::functor() } FunctorWithPromise fWithPromise; { - QtConcurrent::runWithPromise(fWithPromise, 1.5).waitForFinished(); + QtConcurrent::run(fWithPromise, 1.5).waitForFinished(); } OverloadedFunctorWithPromise ofWithPromise; { - QtConcurrent::runWithPromise(ofWithPromise).waitForFinished(); - QtConcurrent::runWithPromise(ofWithPromise).waitForFinished(); - QtConcurrent::runWithPromise(ofWithPromise, 1).waitForFinished(); - QtConcurrent::runWithPromise(ofWithPromise, 1).waitForFinished(); + QtConcurrent::run(ofWithPromise).waitForFinished(); + QtConcurrent::run(ofWithPromise).waitForFinished(); + QtConcurrent::run(ofWithPromise, 1).waitForFinished(); + QtConcurrent::run(ofWithPromise, 1).waitForFinished(); } // and now with explicit pool: QThreadPool pool; @@ -995,13 +996,17 @@ void tst_QtConcurrentRun::functor() // Compiler supports lambda void tst_QtConcurrentRun::lambda() { - QCOMPARE(QtConcurrent::run([](){ return 45; }).result(), 45); - QCOMPARE(QtConcurrent::run([](int a){ return a+15; }, 12).result(), 12+15); - QCOMPARE(QtConcurrent::run([](int a, double b){ return a + b; }, 12, 15).result(), double(12+15)); - QCOMPARE(QtConcurrent::run([](int a , int, int, int, int b){ return a + b; }, 1, 2, 3, 4, 5).result(), 1 + 5); + QCOMPARE(QtConcurrent::run([]() { return 45; }).result(), 45); + QCOMPARE(QtConcurrent::run([](int a) { return a+15; }, 12).result(), 12+15); + QCOMPARE(QtConcurrent::run([](int a, double b) { return a + b; }, 12, 15).result(), + double(12+15)); + QCOMPARE(QtConcurrent::run([](int a , int, int, int, int b) + { return a + b; }, 1, 2, 3, 4, 5).result(), 1 + 5); - QCOMPARE(QtConcurrent::runWithPromise([](QPromise &promise){ promise.addResult(45); }).result(), 45); - QCOMPARE(QtConcurrent::runWithPromise([](QPromise &promise, double input){ promise.addResult(input / 2.0); }, 15.0).result(), 7); + QCOMPARE(QtConcurrent::run([](QPromise &promise) + { promise.addResult(45); }).result(), 45); + QCOMPARE(QtConcurrent::run([](QPromise &promise, double input) + { promise.addResult(input / 2.0); }, 15.0).result(), 7); { QString str { "Hello World Foo" }; @@ -1012,10 +1017,12 @@ void tst_QtConcurrentRun::lambda() // and now with explicit pool: QThreadPool pool; - QCOMPARE(QtConcurrent::run(&pool, [](){ return 45; }).result(), 45); - QCOMPARE(QtConcurrent::run(&pool, [](int a){ return a+15; }, 12).result(), 12+15); - QCOMPARE(QtConcurrent::run(&pool, [](int a, double b){ return a + b; }, 12, 15).result(), double(12+15)); - QCOMPARE(QtConcurrent::run(&pool, [](int a , int, int, int, int b){ return a + b; }, 1, 2, 3, 4, 5).result(), 1 + 5); + QCOMPARE(QtConcurrent::run(&pool, []() { return 45; }).result(), 45); + QCOMPARE(QtConcurrent::run(&pool, [](int a) { return a + 15; }, 12).result(), 12 + 15); + QCOMPARE(QtConcurrent::run(&pool, [](int a, double b) + { return a + b; }, 12, 15).result(), double(12 + 15)); + QCOMPARE(QtConcurrent::run(&pool, [](int a , int, int, int, int b) + { return a + b; }, 1, 2, 3, 4, 5).result(), 1 + 5); { QString str { "Hello World Foo" }; @@ -1065,19 +1072,20 @@ void tst_QtConcurrentRun::callableObjectWithState() CallableWithStateWithPromise oWithPromise; // Run method setNewState explicitly - runWithPromise(&CallableWithStateWithPromise::setNewState, &oWithPromise, CallableWithStateWithPromise::defaultState() + 1).waitForFinished(); + run(&CallableWithStateWithPromise::setNewState, &oWithPromise, + CallableWithStateWithPromise::defaultState() + 1).waitForFinished(); QCOMPARE(oWithPromise.state, CallableWithStateWithPromise::defaultState() + 1); // Run operator()(int) explicitly - runWithPromise(std::ref(oWithPromise), CallableWithStateWithPromise::defaultState() + 2).waitForFinished(); + run(std::ref(oWithPromise), CallableWithStateWithPromise::defaultState() + 2).waitForFinished(); QCOMPARE(oWithPromise.state, CallableWithStateWithPromise::defaultState() + 2); // Run on a copy of object (original object remains unchanged) - runWithPromise(oWithPromise, CallableWithStateWithPromise::defaultState() + 3).waitForFinished(); + run(oWithPromise, CallableWithStateWithPromise::defaultState() + 3).waitForFinished(); QCOMPARE(oWithPromise.state, CallableWithStateWithPromise::defaultState() + 2); // Explicitly run on a temporary object - QCOMPARE(runWithPromise(CallableWithStateWithPromise(), 15).result(), 15); + QCOMPARE(run(CallableWithStateWithPromise(), 15).result(), 15); } void report3(QPromise &promise) @@ -1161,40 +1169,40 @@ public: void tst_QtConcurrentRun::withPromise() { // free function pointer - QCOMPARE(runWithPromise(&report3).results(), + QCOMPARE(run(&report3).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(report3).results(), + QCOMPARE(run(report3).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(reportN, 4).results(), + QCOMPARE(run(reportN, 4).results(), QList({0, 0, 0, 0})); - QCOMPARE(runWithPromise(reportN, 2).results(), + QCOMPARE(run(reportN, 2).results(), QList({0, 0})); QString s = QLatin1String("string"); const QString &crs = QLatin1String("cr string"); const QString cs = QLatin1String("c string"); - QCOMPARE(runWithPromise(reportString1, s).results(), + QCOMPARE(run(reportString1, s).results(), QList({s})); - QCOMPARE(runWithPromise(reportString1, crs).results(), + QCOMPARE(run(reportString1, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(reportString1, cs).results(), + QCOMPARE(run(reportString1, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(reportString1, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(reportString1, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); - QCOMPARE(runWithPromise(reportString2, s).results(), + QCOMPARE(run(reportString2, s).results(), QList({s})); - QCOMPARE(runWithPromise(reportString2, crs).results(), + QCOMPARE(run(reportString2, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(reportString2, cs).results(), + QCOMPARE(run(reportString2, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(reportString2, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(reportString2, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); // lambda - QCOMPARE(runWithPromise([](QPromise &promise, int n) { + QCOMPARE(run([](QPromise &promise, int n) { for (int i = 0; i < n; ++i) promise.addResult(0); }, 3).results(), @@ -1205,46 +1213,46 @@ void tst_QtConcurrentRun::withPromise() for (int i = 0; i < n; ++i) promise.addResult(0); }; - QCOMPARE(runWithPromise(fun, 2).results(), + QCOMPARE(run(fun, 2).results(), QList({0, 0})); // operator() - QCOMPARE(runWithPromise(Callable(), 3).results(), + QCOMPARE(run(Callable(), 3).results(), QList({0, 0, 0})); const Callable c{}; - QCOMPARE(runWithPromise(c, 2).results(), + QCOMPARE(run(c, 2).results(), QList({0, 0})); // static member functions - QCOMPARE(runWithPromise(&MyObject::staticMember0).results(), + QCOMPARE(run(&MyObject::staticMember0).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(&MyObject::staticMember1, 2).results(), + QCOMPARE(run(&MyObject::staticMember1, 2).results(), QList({0, 0})); // member functions const MyObject obj{}; - QCOMPARE(runWithPromise(&MyObject::member0, &obj).results(), + QCOMPARE(run(&MyObject::member0, &obj).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(&MyObject::member1, &obj, 4).results(), + QCOMPARE(run(&MyObject::member1, &obj, 4).results(), QList({0, 0, 0, 0})); - QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, s).results(), + QCOMPARE(run(&MyObject::memberString1, &obj, s).results(), QList({s})); - QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, crs).results(), + QCOMPARE(run(&MyObject::memberString1, &obj, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, cs).results(), + QCOMPARE(run(&MyObject::memberString1, &obj, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(&MyObject::memberString1, &obj, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); - QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, s).results(), + QCOMPARE(run(&MyObject::memberString2, &obj, s).results(), QList({s})); - QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, crs).results(), + QCOMPARE(run(&MyObject::memberString2, &obj, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, cs).results(), + QCOMPARE(run(&MyObject::memberString2, &obj, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(&MyObject::memberString2, &obj, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); MyObject nonConstObj{}; - QCOMPARE(runWithPromise(&MyObject::nonConstMember, &nonConstObj).results(), + QCOMPARE(run(&MyObject::nonConstMember, &nonConstObj).results(), QList({0, 2, 1})); } @@ -1252,40 +1260,40 @@ void tst_QtConcurrentRun::withPromiseInThreadPool() { QScopedPointer pool(new QThreadPool); // free function pointer - QCOMPARE(runWithPromise(pool.data(), &report3).results(), + QCOMPARE(run(pool.data(), &report3).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(pool.data(), report3).results(), + QCOMPARE(run(pool.data(), report3).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(pool.data(), reportN, 4).results(), + QCOMPARE(run(pool.data(), reportN, 4).results(), QList({0, 0, 0, 0})); - QCOMPARE(runWithPromise(pool.data(), reportN, 2).results(), + QCOMPARE(run(pool.data(), reportN, 2).results(), QList({0, 0})); QString s = QLatin1String("string"); const QString &crs = QLatin1String("cr string"); const QString cs = QLatin1String("c string"); - QCOMPARE(runWithPromise(pool.data(), reportString1, s).results(), + QCOMPARE(run(pool.data(), reportString1, s).results(), QList({s})); - QCOMPARE(runWithPromise(pool.data(), reportString1, crs).results(), + QCOMPARE(run(pool.data(), reportString1, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(pool.data(), reportString1, cs).results(), + QCOMPARE(run(pool.data(), reportString1, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(pool.data(), reportString1, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(pool.data(), reportString1, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); - QCOMPARE(runWithPromise(pool.data(), reportString2, s).results(), + QCOMPARE(run(pool.data(), reportString2, s).results(), QList({s})); - QCOMPARE(runWithPromise(pool.data(), reportString2, crs).results(), + QCOMPARE(run(pool.data(), reportString2, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(pool.data(), reportString2, cs).results(), + QCOMPARE(run(pool.data(), reportString2, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(pool.data(), reportString2, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(pool.data(), reportString2, QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); // lambda - QCOMPARE(runWithPromise(pool.data(), [](QPromise &promise, int n) { + QCOMPARE(run(pool.data(), [](QPromise &promise, int n) { for (int i = 0; i < n; ++i) promise.addResult(0); }, 3).results(), @@ -1296,43 +1304,45 @@ void tst_QtConcurrentRun::withPromiseInThreadPool() for (int i = 0; i < n; ++i) promise.addResult(0); }; - QCOMPARE(runWithPromise(pool.data(), fun, 2).results(), + QCOMPARE(run(pool.data(), fun, 2).results(), QList({0, 0})); // operator() - QCOMPARE(runWithPromise(pool.data(), Callable(), 3).results(), + QCOMPARE(run(pool.data(), Callable(), 3).results(), QList({0, 0, 0})); const Callable c{}; - QCOMPARE(runWithPromise(pool.data(), c, 2).results(), + QCOMPARE(run(pool.data(), c, 2).results(), QList({0, 0})); // static member functions - QCOMPARE(runWithPromise(pool.data(), &MyObject::staticMember0).results(), + QCOMPARE(run(pool.data(), &MyObject::staticMember0).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::staticMember1, 2).results(), + QCOMPARE(run(pool.data(), &MyObject::staticMember1, 2).results(), QList({0, 0})); // member functions const MyObject obj{}; - QCOMPARE(runWithPromise(pool.data(), &MyObject::member0, &obj).results(), + QCOMPARE(run(pool.data(), &MyObject::member0, &obj).results(), QList({0, 2, 1})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::member1, &obj, 4).results(), + QCOMPARE(run(pool.data(), &MyObject::member1, &obj, 4).results(), QList({0, 0, 0, 0})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, s).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, s).results(), QList({s})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, crs).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, cs).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, + QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, s).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, s).results(), QList({s})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, crs).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, crs).results(), QList({crs})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, cs).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, cs).results(), QList({cs})); - QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, QString(QLatin1String("rvalue"))).results(), + QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, + QString(QLatin1String("rvalue"))).results(), QList({QString(QLatin1String("rvalue"))})); } @@ -1357,44 +1367,92 @@ public: void tst_QtConcurrentRun::moveOnlyType() { - QCOMPARE(runWithPromise(MoveOnlyCallable(), MoveOnlyType()).results(), + QCOMPARE(run(MoveOnlyCallable(), MoveOnlyType()).results(), QList({1})); } void tst_QtConcurrentRun::crefFunction() { - // free function pointer with promise - auto fun = &report3; - QCOMPARE(runWithPromise(std::cref(fun)).results(), - QList({0, 2, 1})); - - // lambda with promise - auto lambda = [](QPromise &promise, int n) { - for (int i = 0; i < n; ++i) - promise.addResult(0); - }; - QCOMPARE(runWithPromise(std::cref(lambda), 3).results(), - QList({0, 0, 0})); + { + // free function pointer with promise + auto fun = &returnInt0; + QCOMPARE(run(std::cref(fun)).result(), 10); + + // lambda with promise + auto lambda = [](int n) { + return 2 * n; + }; + QCOMPARE(run(std::cref(lambda), 3).result(), 6); + + // std::function with promise + const std::function funObj = [](int n) { + return 2 * n; + }; + QCOMPARE(run(std::cref(funObj), 2).result(), 4); + + // callable with promise + const AConst c{}; + QCOMPARE(run(std::cref(c), 2).result(), 2); + + // member functions with promise + auto member = &AConst::member0; + const AConst obj{}; + QCOMPARE(run(std::cref(member), &obj).result(), 10); + } - // std::function with promise - const std::function &, int)> funObj = [](QPromise &promise, int n) { - for (int i = 0; i < n; ++i) - promise.addResult(0); - }; - QCOMPARE(runWithPromise(std::cref(funObj), 2).results(), - QList({0, 0})); + { + // free function pointer with promise + auto fun = &report3; + QCOMPARE(run(std::cref(fun)).results(), + QList({0, 2, 1})); + + // lambda with promise + auto lambda = [](QPromise &promise, int n) { + for (int i = 0; i < n; ++i) + promise.addResult(0); + }; + QCOMPARE(run(std::cref(lambda), 3).results(), + QList({0, 0, 0})); + + // std::function with promise + const std::function &, int)> funObj = + [](QPromise &promise, int n) { + for (int i = 0; i < n; ++i) + promise.addResult(0); + }; + QCOMPARE(run(std::cref(funObj), 2).results(), + QList({0, 0})); + + // callable with promise + const Callable c{}; + QCOMPARE(run(std::cref(c), 2).results(), + QList({0, 0})); + + // member functions with promise + auto member = &MyObject::member0; + const MyObject obj{}; + QCOMPARE(run(std::cref(member), &obj).results(), + QList({0, 2, 1})); + } +} - // callable with promise - const Callable c{}; - QCOMPARE(runWithPromise(std::cref(c), 2).results(), - QList({0, 0})); +int explicitPromise(QPromise &promise, int &i) +{ + promise.setProgressRange(-10, 10); + ++i; + return i * 2; +} - // member functions with promise - auto member = &MyObject::member0; - const MyObject obj{}; - QCOMPARE(runWithPromise(std::cref(member), &obj).results(), - QList({0, 2, 1})); +void tst_QtConcurrentRun::customPromise() +{ + QPromise p; + int i = 4; + QCOMPARE(QtConcurrent::run(explicitPromise, std::ref(p), std::ref(i)).result(), 10); + QCOMPARE(i, 5); + QCOMPARE(p.future().progressMinimum(), -10); + QCOMPARE(p.future().progressMaximum(), 10); } + QTEST_MAIN(tst_QtConcurrentRun) #include "tst_qtconcurrentrun.moc" -- cgit v1.2.3