Rename qPromiseAll() helper to QtPromise::all()

For consistency with other helpers, deprecate `qPromiseAll()` in favor of `QtPromise::all()`.

tests/auto/qtpromise/deprecations/helpers/helpers.pro

@@ -1,3 +1,4 @@
 TEMPLATE = subdirs
 SUBDIRS += \
-    qpromise
+    qpromise \
+    qpromiseall

tests/auto/qtpromise/deprecations/helpers/qpromiseall/qpromiseall.pro

@@ -0,0 +1,4 @@
+TARGET = tst_deprecations_helpers_qpromiseall
+SOURCES += $$PWD/tst_qpromiseall.cpp
+
+include(../../deprecations.pri)

tests/auto/qtpromise/deprecations/helpers/qpromiseall/tst_qpromiseall.cpp

@@ -0,0 +1,220 @@
+#include "../../../shared/utils.h"
+
+// QtPromise
+#include <QtPromise>
+
+// Qt
+#include <QtTest>
+
+using namespace QtPromise;
+
+class tst_deprecations_helpers_qpromiseall : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void emptySequence();
+    void emptySequence_void();
+    void allPromisesSucceed();
+    void allPromisesSucceed_void();
+    void atLeastOnePromiseReject();
+    void atLeastOnePromiseReject_void();
+    void preserveOrder();
+    void sequenceTypes();
+    void sequenceTypes_void();
+};
+
+QTEST_MAIN(tst_deprecations_helpers_qpromiseall)
+#include "tst_qpromiseall.moc"
+
+namespace {
+
+template <class Sequence>
+struct SequenceTester
+{
+    Q_STATIC_ASSERT((std::is_same<typename Sequence::value_type, QPromise<int>>::value));
+
+    static void exec()
+    {
+        Sequence promises{
+            QtPromise::resolve(42),
+            QtPromise::resolve(43),
+            QtPromise::resolve(44)
+        };
+
+        promises.push_back(QtPromise::resolve(45));
+        promises.insert(++promises.begin(), QtPromise::resolve(46));
+        promises.pop_back();
+
+        auto p = qPromiseAll(promises);
+
+        Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+        QCOMPARE(p.isPending(), true);
+        QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 46, 43, 44}));
+    }
+};
+
+template <template <typename, typename...> class Sequence, typename ...Args>
+struct SequenceTester<Sequence<QPromise<void>, Args...>>
+{
+    static void exec()
+    {
+        Sequence<QPromise<void>, Args...> promises{
+            QtPromise::resolve(),
+            QtPromise::resolve(),
+            QtPromise::resolve()
+        };
+
+        promises.push_back(QtPromise::resolve());
+        promises.insert(++promises.begin(), QtPromise::resolve());
+        promises.pop_back();
+
+        auto p = qPromiseAll(promises);
+
+        Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+        QCOMPARE(p.isPending(), true);
+        QCOMPARE(waitForValue(p, -1, 42), 42);
+    }
+};
+
+} // anonymous namespace
+
+void tst_deprecations_helpers_qpromiseall::emptySequence()
+{
+    auto p = qPromiseAll(QVector<QPromise<int>>());
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+    QCOMPARE(p.isFulfilled(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({}));
+}
+
+void tst_deprecations_helpers_qpromiseall::emptySequence_void()
+{
+    auto p = qPromiseAll(QVector<QPromise<void>>());
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+    QCOMPARE(p.isFulfilled(), true);
+    QCOMPARE(waitForValue(p, -1, 42), 42);
+}
+
+void tst_deprecations_helpers_qpromiseall::allPromisesSucceed()
+{
+    auto p0 = QtPromise::resolve(42);
+    auto p1 = QtPromise::resolve(44);
+    auto p2 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            resolve(43);
+        });
+    });
+
+    auto p = qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+void tst_deprecations_helpers_qpromiseall::allPromisesSucceed_void()
+{
+    auto p0 = QtPromise::resolve();
+    auto p1 = QtPromise::resolve();
+    auto p2 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            resolve();
+        });
+    });
+
+    auto p = qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, -1, 42), 42);
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject()
+{
+    auto p0 = QtPromise::resolve(42);
+    auto p1 = QtPromise::resolve(44);
+    auto p2 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            reject(QString("foo"));
+        });
+    });
+
+    auto p = qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForError(p, QString()), QString("foo"));
+    QCOMPARE(p2.isRejected(), true);
+}
+
+void tst_deprecations_helpers_qpromiseall::atLeastOnePromiseReject_void()
+{
+    auto p0 = QtPromise::resolve();
+    auto p1 = QtPromise::resolve();
+    auto p2 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            reject(QString("foo"));
+        });
+    });
+
+    auto p = qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForError(p, QString()), QString("foo"));
+    QCOMPARE(p2.isRejected(), true);
+}
+
+void tst_deprecations_helpers_qpromiseall::preserveOrder()
+{
+    auto p0 = QtPromise::resolve(42).delay(500);
+    auto p1 = QtPromise::resolve(43).delay(100);
+    auto p2 = QtPromise::resolve(44).delay(250);
+
+    auto p = qPromiseAll(QVector<QPromise<int>>{p0, p1, p2});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+    QCOMPARE(p0.isPending(), true);
+    QCOMPARE(p1.isPending(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+// QVector::push_back/append isn't supported since it requires a default
+// constructor (see https://github.com/simonbrunel/qtpromise/issues/3)
+
+void tst_deprecations_helpers_qpromiseall::sequenceTypes()
+{
+    SequenceTester<QList<QPromise<int>>>::exec();
+    //SequenceTester<QVector<QPromise<int>>>::exec();
+    SequenceTester<std::list<QPromise<int>>>::exec();
+    SequenceTester<std::vector<QPromise<int>>>::exec();
+}
+
+void tst_deprecations_helpers_qpromiseall::sequenceTypes_void()
+{
+    SequenceTester<QList<QPromise<void>>>::exec();
+    //SequenceTester<QVector<QPromise<void>>>::exec();
+    SequenceTester<std::list<QPromise<void>>>::exec();
+    SequenceTester<std::vector<QPromise<void>>>::exec();
+}

tests/auto/qtpromise/deprecations/qpromise/all/all.pro

@@ -0,0 +1,4 @@
+TARGET = tst_deprecations_qpromise_all
+SOURCES += $$PWD/tst_all.cpp
+
+include(../../deprecations.pri)

tests/auto/qtpromise/deprecations/qpromise/all/tst_all.cpp

@@ -0,0 +1,229 @@
+#include "../../../shared/utils.h"
+
+// QtPromise
+#include <QtPromise>
+
+// Qt
+#include <QtTest>
+
+using namespace QtPromise;
+
+class tst_deprecations_qpromise_all : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void emptySequence();
+    void emptySequence_void();
+    void allPromisesSucceed();
+    void allPromisesSucceed_void();
+    void atLeastOnePromiseReject();
+    void atLeastOnePromiseReject_void();
+    void preserveOrder();
+    void sequenceTypes();
+    void sequenceTypes_void();
+};
+
+QTEST_MAIN(tst_deprecations_qpromise_all)
+#include "tst_all.moc"
+
+namespace {
+
+template <class Sequence>
+struct SequenceTester
+{
+    Q_STATIC_ASSERT((std::is_same<typename Sequence::value_type, QPromise<int>>::value));
+
+    static void exec()
+    {
+        Sequence promises{
+            QtPromise::resolve(42),
+            QtPromise::resolve(43),
+            QtPromise::resolve(44)
+        };
+
+        promises.push_back(QtPromise::resolve(45));
+        promises.insert(++promises.begin(), QtPromise::resolve(46));
+        promises.pop_back();
+
+        auto p = QPromise<int>::all(promises);
+
+        Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+
+        QCOMPARE(p.isPending(), true);
+        QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 46, 43, 44}));
+    }
+};
+
+template <template <typename, typename...> class Sequence, typename ...Args>
+struct SequenceTester<Sequence<QPromise<void>, Args...>>
+{
+    static void exec()
+    {
+        Sequence<QPromise<void>, Args...> promises{
+            QtPromise::resolve(),
+            QtPromise::resolve(),
+            QtPromise::resolve()
+        };
+
+        promises.push_back(QtPromise::resolve());
+        promises.insert(++promises.begin(), QtPromise::resolve());
+        promises.pop_back();
+
+        auto p = QPromise<void>::all(promises);
+
+        Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+
+        QCOMPARE(p.isPending(), true);
+        QCOMPARE(waitForValue(p, -1, 42), 42);
+    }
+};
+
+} // anonymous namespace
+
+void tst_deprecations_qpromise_all::emptySequence()
+{
+    auto p = QPromise<int>::all({});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+
+    QCOMPARE(p.isFulfilled(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>{});
+}
+
+void tst_deprecations_qpromise_all::emptySequence_void()
+{
+    auto p = QPromise<void>::all({});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+
+    QCOMPARE(p.isFulfilled(), true);
+    QCOMPARE(waitForValue(p, -1, 42), 42);
+}
+
+void tst_deprecations_qpromise_all::allPromisesSucceed()
+{
+    auto p0 = QtPromise::resolve(42);
+    auto p1 = QtPromise::resolve(44);
+    auto p2 = QPromise<int>([](const QPromiseResolve<int>& resolve) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            resolve(43);
+        });
+    });
+
+    auto p = QPromise<int>::all({p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+void tst_deprecations_qpromise_all::allPromisesSucceed_void()
+{
+    auto p0 = QtPromise::resolve();
+    auto p1 = QtPromise::resolve();
+    auto p2 = QPromise<void>([](const QPromiseResolve<void>& resolve) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            resolve();
+        });
+    });
+
+    auto p = QPromise<void>::all({p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, -1, 42), 42);
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+void tst_deprecations_qpromise_all::atLeastOnePromiseReject()
+{
+    auto p0 = QtPromise::resolve(42);
+    auto p1 = QtPromise::resolve(44);
+    auto p2 = QPromise<int>([](const QPromiseResolve<int>&, const QPromiseReject<int>& reject) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            reject(QString("foo"));
+        });
+    });
+
+    auto p = QPromise<int>::all({p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForError(p, QString()), QString("foo"));
+    QCOMPARE(p2.isRejected(), true);
+}
+
+void tst_deprecations_qpromise_all::atLeastOnePromiseReject_void()
+{
+    auto p0 = QtPromise::resolve();
+    auto p1 = QtPromise::resolve();
+    auto p2 = QPromise<void>([](const QPromiseResolve<void>&, const QPromiseReject<void>& reject) {
+        QtPromisePrivate::qtpromise_defer([=](){
+            reject(QString("foo"));
+        });
+    });
+
+    auto p = QPromise<void>::all({p0, p2, p1});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
+
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForError(p, QString()), QString("foo"));
+    QCOMPARE(p2.isRejected(), true);
+}
+
+void tst_deprecations_qpromise_all::preserveOrder()
+{
+    auto p0 = QtPromise::resolve(42).delay(500);
+    auto p1 = QtPromise::resolve(43).delay(100);
+    auto p2 = QtPromise::resolve(44).delay(250);
+
+    auto p = QPromise<int>::all({p0, p1, p2});
+
+    Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
+
+    QCOMPARE(p0.isPending(), true);
+    QCOMPARE(p1.isPending(), true);
+    QCOMPARE(p2.isPending(), true);
+    QCOMPARE(p.isPending(), true);
+    QCOMPARE(waitForValue(p, QVector<int>()), QVector<int>({42, 43, 44}));
+    QCOMPARE(p0.isFulfilled(), true);
+    QCOMPARE(p1.isFulfilled(), true);
+    QCOMPARE(p2.isFulfilled(), true);
+}
+
+// QVector::push_back/append isn't supported since it requires a default
+// constructor (see https://github.com/simonbrunel/qtpromise/issues/3)
+
+void tst_deprecations_qpromise_all::sequenceTypes()
+{
+    SequenceTester<QList<QPromise<int>>>::exec();
+    //SequenceTester<QVector<QPromise<int>>>::exec();
+    SequenceTester<std::list<QPromise<int>>>::exec();
+    SequenceTester<std::vector<QPromise<int>>>::exec();
+}
+
+void tst_deprecations_qpromise_all::sequenceTypes_void()
+{
+    SequenceTester<QList<QPromise<void>>>::exec();
+    //SequenceTester<QVector<QPromise<void>>>::exec();
+    SequenceTester<std::list<QPromise<void>>>::exec();
+    SequenceTester<std::vector<QPromise<void>>>::exec();
+}

tests/auto/qtpromise/deprecations/qpromise/qpromise.pro

@@ -0,0 +1,3 @@
+TEMPLATE = subdirs
+SUBDIRS += \
+    all

tests/auto/qtpromise/helpers/all/tst_all.cpp

@@ -46,7 +46,7 @@ struct SequenceTester
         promises.insert(++promises.begin(), QtPromise::resolve(46));
         promises.pop_back();
 
-        auto p = QtPromise::qPromiseAll(promises);
+        auto p = QtPromise::all(promises);
 
         Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
         QCOMPARE(p.isPending(), true);
@@ -69,7 +69,7 @@ struct SequenceTester<Sequence<QPromise<void>, Args...>>
         promises.insert(++promises.begin(), QtPromise::resolve());
         promises.pop_back();
 
-        auto p = QtPromise::qPromiseAll(promises);
+        auto p = QtPromise::all(promises);
 
         Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
         QCOMPARE(p.isPending(), true);
@@ -81,7 +81,7 @@ struct SequenceTester<Sequence<QPromise<void>, Args...>>
 
 void tst_helpers_all::emptySequence()
 {
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<int>>());
+    auto p = QtPromise::all(QVector<QPromise<int>>());
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
     QCOMPARE(p.isFulfilled(), true);
@@ -90,7 +90,7 @@ void tst_helpers_all::emptySequence()
 
 void tst_helpers_all::emptySequence_void()
 {
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<void>>());
+    auto p = QtPromise::all(QVector<QPromise<void>>());
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
     QCOMPARE(p.isFulfilled(), true);
@@ -107,7 +107,7 @@ void tst_helpers_all::allPromisesSucceed()
         });
     });
 
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
+    auto p = QtPromise::all(QVector<QPromise<int>>{p0, p2, p1});
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
     QCOMPARE(p0.isFulfilled(), true);
@@ -128,7 +128,7 @@ void tst_helpers_all::allPromisesSucceed_void()
         });
     });
 
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
+    auto p = QtPromise::all(QVector<QPromise<void>>{p0, p2, p1});
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
     QCOMPARE(p0.isFulfilled(), true);
@@ -149,7 +149,7 @@ void tst_helpers_all::atLeastOnePromiseReject()
         });
     });
 
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<int>>{p0, p2, p1});
+    auto p = QtPromise::all(QVector<QPromise<int>>{p0, p2, p1});
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
     QCOMPARE(p0.isFulfilled(), true);
@@ -170,7 +170,7 @@ void tst_helpers_all::atLeastOnePromiseReject_void()
         });
     });
 
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<void>>{p0, p2, p1});
+    auto p = QtPromise::all(QVector<QPromise<void>>{p0, p2, p1});
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<void>>::value));
     QCOMPARE(p0.isFulfilled(), true);
@@ -187,7 +187,7 @@ void tst_helpers_all::preserveOrder()
     auto p1 = QtPromise::resolve(43).delay(100);
     auto p2 = QtPromise::resolve(44).delay(250);
 
-    auto p = QtPromise::qPromiseAll(QVector<QPromise<int>>{p0, p1, p2});
+    auto p = QtPromise::all(QVector<QPromise<int>>{p0, p1, p2});
 
     Q_STATIC_ASSERT((std::is_same<decltype(p), QPromise<QVector<int>>>::value));
     QCOMPARE(p0.isPending(), true);

tests/auto/qtpromise/requirements/tst_requirements.cpp

@@ -279,7 +279,7 @@ void tst_requirements::thenMultipleCalls()
             });
         });
 
-        qPromiseAll(QVector<QPromise<void>>{
+        QtPromise::all(QVector<QPromise<void>>{
             p.then([&](int r) { values << r + 1; }),
             p.then([&](int r) { values << r + 2; }),
             p.then([&](int r) { values << r + 3; })
@@ -298,7 +298,7 @@ void tst_requirements::thenMultipleCalls()
             });
         });
 
-        qPromiseAll(QVector<QPromise<int>>{
+        QtPromise::all(QVector<QPromise<int>>{
             p.then(nullptr, [&](int r) { values << r + 1; return r + 1; }),
             p.then(nullptr, [&](int r) { values << r + 2; return r + 2; }),
             p.then(nullptr, [&](int r) { values << r + 3; return r + 3; })