QtConcurrent: Integrate runWithPromise into run

Change-Id: I6eb95aa66ff847e8bb9aac348fded3a5d55015b6
Reviewed-by: Paul Wicking <paul.wicking@qt.io>
Reviewed-by: Sona Kurazyan <sona.kurazyan@qt.io>

1 files changed, 217 insertions, 159 deletions

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<int> &) = lightOverloaded;
     qDebug("starting function with promise");
-    QFuture<void> future3 = runWithPromise(f3);
+    QFuture<void> future3 = run(f3);
     qDebug("waiting");
     future3.waitForFinished();
     qDebug("done");
 
     void (*f4)(QPromise<double> &, int v) = lightOverloaded;
     qDebug("starting function with promise and with arg");
-    QFuture<void> future4 = runWithPromise(f4, 2);
+    QFuture<void> future4 = run(f4, 2);
     qDebug("waiting");
     future4.waitForFinished();
     qDebug("done");
@@ -429,141 +430,141 @@ void tst_QtConcurrentRun::reportValueWithPromise()
     QThreadPool pool;
     QFuture<int> 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<int>(ofWithPromise).waitForFinished();
-        QtConcurrent::runWithPromise<double>(ofWithPromise).waitForFinished();
-        QtConcurrent::runWithPromise<int>(ofWithPromise, 1).waitForFinished();
-        QtConcurrent::runWithPromise<double>(ofWithPromise, 1).waitForFinished();
+        QtConcurrent::run<int>(ofWithPromise).waitForFinished();
+        QtConcurrent::run<double>(ofWithPromise).waitForFinished();
+        QtConcurrent::run<int>(ofWithPromise, 1).waitForFinished();
+        QtConcurrent::run<double>(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<int> &promise){ promise.addResult(45); }).result(), 45);
-    QCOMPARE(QtConcurrent::runWithPromise([](QPromise<int> &promise, double input){ promise.addResult(input / 2.0); }, 15.0).result(), 7);
+    QCOMPARE(QtConcurrent::run([](QPromise<int> &promise)
+             { promise.addResult(45); }).result(), 45);
+    QCOMPARE(QtConcurrent::run([](QPromise<int> &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<int> &promise)
@@ -1161,40 +1169,40 @@ public:
 void tst_QtConcurrentRun::withPromise()
 {
     // free function pointer
-    QCOMPARE(runWithPromise(&report3).results(),
+    QCOMPARE(run(&report3).results(),
              QList<int>({0, 2, 1}));
-    QCOMPARE(runWithPromise(report3).results(),
+    QCOMPARE(run(report3).results(),
              QList<int>({0, 2, 1}));
 
-    QCOMPARE(runWithPromise(reportN, 4).results(),
+    QCOMPARE(run(reportN, 4).results(),
              QList<double>({0, 0, 0, 0}));
-    QCOMPARE(runWithPromise(reportN, 2).results(),
+    QCOMPARE(run(reportN, 2).results(),
              QList<double>({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<QString>({s}));
-    QCOMPARE(runWithPromise(reportString1, crs).results(),
+    QCOMPARE(run(reportString1, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(reportString1, cs).results(),
+    QCOMPARE(run(reportString1, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(reportString1, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(reportString1, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
 
-    QCOMPARE(runWithPromise(reportString2, s).results(),
+    QCOMPARE(run(reportString2, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(reportString2, crs).results(),
+    QCOMPARE(run(reportString2, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(reportString2, cs).results(),
+    QCOMPARE(run(reportString2, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(reportString2, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(reportString2, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
 
     // lambda
-    QCOMPARE(runWithPromise([](QPromise<double> &promise, int n) {
+    QCOMPARE(run([](QPromise<double> &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<double>({0, 0}));
 
     // operator()
-    QCOMPARE(runWithPromise(Callable(), 3).results(),
+    QCOMPARE(run(Callable(), 3).results(),
              QList<double>({0, 0, 0}));
     const Callable c{};
-    QCOMPARE(runWithPromise(c, 2).results(),
+    QCOMPARE(run(c, 2).results(),
              QList<double>({0, 0}));
 
     // static member functions
-    QCOMPARE(runWithPromise(&MyObject::staticMember0).results(),
+    QCOMPARE(run(&MyObject::staticMember0).results(),
              QList<double>({0, 2, 1}));
-    QCOMPARE(runWithPromise(&MyObject::staticMember1, 2).results(),
+    QCOMPARE(run(&MyObject::staticMember1, 2).results(),
              QList<double>({0, 0}));
 
     // member functions
     const MyObject obj{};
-    QCOMPARE(runWithPromise(&MyObject::member0, &obj).results(),
+    QCOMPARE(run(&MyObject::member0, &obj).results(),
              QList<double>({0, 2, 1}));
-    QCOMPARE(runWithPromise(&MyObject::member1, &obj, 4).results(),
+    QCOMPARE(run(&MyObject::member1, &obj, 4).results(),
              QList<double>({0, 0, 0, 0}));
-    QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, s).results(),
+    QCOMPARE(run(&MyObject::memberString1, &obj, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, crs).results(),
+    QCOMPARE(run(&MyObject::memberString1, &obj, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, cs).results(),
+    QCOMPARE(run(&MyObject::memberString1, &obj, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(&MyObject::memberString1, &obj, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(&MyObject::memberString1, &obj, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
-    QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, s).results(),
+    QCOMPARE(run(&MyObject::memberString2, &obj, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, crs).results(),
+    QCOMPARE(run(&MyObject::memberString2, &obj, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, cs).results(),
+    QCOMPARE(run(&MyObject::memberString2, &obj, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(&MyObject::memberString2, &obj, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(&MyObject::memberString2, &obj, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
     MyObject nonConstObj{};
-    QCOMPARE(runWithPromise(&MyObject::nonConstMember, &nonConstObj).results(),
+    QCOMPARE(run(&MyObject::nonConstMember, &nonConstObj).results(),
              QList<double>({0, 2, 1}));
 }
 
@@ -1252,40 +1260,40 @@ void tst_QtConcurrentRun::withPromiseInThreadPool()
 {
     QScopedPointer<QThreadPool> pool(new QThreadPool);
     // free function pointer
-    QCOMPARE(runWithPromise(pool.data(), &report3).results(),
+    QCOMPARE(run(pool.data(), &report3).results(),
              QList<int>({0, 2, 1}));
-    QCOMPARE(runWithPromise(pool.data(), report3).results(),
+    QCOMPARE(run(pool.data(), report3).results(),
              QList<int>({0, 2, 1}));
 
-    QCOMPARE(runWithPromise(pool.data(), reportN, 4).results(),
+    QCOMPARE(run(pool.data(), reportN, 4).results(),
              QList<double>({0, 0, 0, 0}));
-    QCOMPARE(runWithPromise(pool.data(), reportN, 2).results(),
+    QCOMPARE(run(pool.data(), reportN, 2).results(),
              QList<double>({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<QString>({s}));
-    QCOMPARE(runWithPromise(pool.data(), reportString1, crs).results(),
+    QCOMPARE(run(pool.data(), reportString1, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(pool.data(), reportString1, cs).results(),
+    QCOMPARE(run(pool.data(), reportString1, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(pool.data(), reportString1, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(pool.data(), reportString1, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
 
-    QCOMPARE(runWithPromise(pool.data(), reportString2, s).results(),
+    QCOMPARE(run(pool.data(), reportString2, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(pool.data(), reportString2, crs).results(),
+    QCOMPARE(run(pool.data(), reportString2, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(pool.data(), reportString2, cs).results(),
+    QCOMPARE(run(pool.data(), reportString2, cs).results(),
              QList<QString>({cs}));
-    QCOMPARE(runWithPromise(pool.data(), reportString2, QString(QLatin1String("rvalue"))).results(),
+    QCOMPARE(run(pool.data(), reportString2, QString(QLatin1String("rvalue"))).results(),
              QList<QString>({QString(QLatin1String("rvalue"))}));
 
     // lambda
-    QCOMPARE(runWithPromise(pool.data(), [](QPromise<double> &promise, int n) {
+    QCOMPARE(run(pool.data(), [](QPromise<double> &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<double>({0, 0}));
 
     // operator()
-    QCOMPARE(runWithPromise(pool.data(), Callable(), 3).results(),
+    QCOMPARE(run(pool.data(), Callable(), 3).results(),
              QList<double>({0, 0, 0}));
     const Callable c{};
-    QCOMPARE(runWithPromise(pool.data(), c, 2).results(),
+    QCOMPARE(run(pool.data(), c, 2).results(),
              QList<double>({0, 0}));
 
     // static member functions
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::staticMember0).results(),
+    QCOMPARE(run(pool.data(), &MyObject::staticMember0).results(),
              QList<double>({0, 2, 1}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::staticMember1, 2).results(),
+    QCOMPARE(run(pool.data(), &MyObject::staticMember1, 2).results(),
              QList<double>({0, 0}));
 
     // member functions
     const MyObject obj{};
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::member0, &obj).results(),
+    QCOMPARE(run(pool.data(), &MyObject::member0, &obj).results(),
              QList<double>({0, 2, 1}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::member1, &obj, 4).results(),
+    QCOMPARE(run(pool.data(), &MyObject::member1, &obj, 4).results(),
              QList<double>({0, 0, 0, 0}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, s).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, crs).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString1, &obj, cs).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString1, &obj, cs).results(),
              QList<QString>({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>({QString(QLatin1String("rvalue"))}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, s).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, s).results(),
              QList<QString>({s}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, crs).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, crs).results(),
              QList<QString>({crs}));
-    QCOMPARE(runWithPromise(pool.data(), &MyObject::memberString2, &obj, cs).results(),
+    QCOMPARE(run(pool.data(), &MyObject::memberString2, &obj, cs).results(),
              QList<QString>({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>({QString(QLatin1String("rvalue"))}));
 }
 
@@ -1357,44 +1367,92 @@ public:
 
 void tst_QtConcurrentRun::moveOnlyType()
 {
-    QCOMPARE(runWithPromise(MoveOnlyCallable(), MoveOnlyType()).results(),
+    QCOMPARE(run(MoveOnlyCallable(), MoveOnlyType()).results(),
              QList<int>({1}));
 }
 
 void tst_QtConcurrentRun::crefFunction()
 {
-    // free function pointer with promise
-    auto fun = &report3;
-    QCOMPARE(runWithPromise(std::cref(fun)).results(),
-             QList<int>({0, 2, 1}));
-
-    // lambda with promise
-    auto lambda = [](QPromise<double> &promise, int n) {
-        for (int i = 0; i < n; ++i)
-            promise.addResult(0);
-    };
-    QCOMPARE(runWithPromise(std::cref(lambda), 3).results(),
-             QList<double>({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<int(int)> 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<void(QPromise<double> &, int)> funObj = [](QPromise<double> &promise, int n) {
-        for (int i = 0; i < n; ++i)
-            promise.addResult(0);
-    };
-    QCOMPARE(runWithPromise(std::cref(funObj), 2).results(),
-             QList<double>({0, 0}));
+    {
+        // free function pointer with promise
+        auto fun = &report3;
+        QCOMPARE(run(std::cref(fun)).results(),
+                 QList<int>({0, 2, 1}));
+
+        // lambda with promise
+        auto lambda = [](QPromise<double> &promise, int n) {
+            for (int i = 0; i < n; ++i)
+                promise.addResult(0);
+        };
+        QCOMPARE(run(std::cref(lambda), 3).results(),
+                 QList<double>({0, 0, 0}));
+
+        // std::function with promise
+        const std::function<void(QPromise<double> &, int)> funObj =
+                [](QPromise<double> &promise, int n) {
+            for (int i = 0; i < n; ++i)
+                promise.addResult(0);
+        };
+        QCOMPARE(run(std::cref(funObj), 2).results(),
+                 QList<double>({0, 0}));
+
+        // callable with promise
+        const Callable c{};
+        QCOMPARE(run(std::cref(c), 2).results(),
+                 QList<double>({0, 0}));
+
+        // member functions with promise
+        auto member = &MyObject::member0;
+        const MyObject obj{};
+        QCOMPARE(run(std::cref(member), &obj).results(),
+                 QList<double>({0, 2, 1}));
+    }
+}
 
-    // callable with promise
-    const Callable c{};
-    QCOMPARE(runWithPromise(std::cref(c), 2).results(),
-             QList<double>({0, 0}));
+int explicitPromise(QPromise<int> &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<double>({0, 2, 1}));
+void tst_QtConcurrentRun::customPromise()
+{
+    QPromise<int> 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"