Async: allow consumer continuation without arguments

It is now possible to chain a job that takes no arguments after a job
that returns void.

Unfortunatelly it is not yet possible to disregard return value of a
previous job.

1 files changed, 91 insertions, 4 deletions

diff --git a/async/autotests/asynctest.cpp b/async/autotests/asynctest.cpp
index 7437608..1074ff0 100644
--- a/async/autotests/asynctest.cpp
+++ b/async/autotests/asynctest.cpp
@@ -48,18 +48,20 @@ private Q_SLOTS:
     void testAsyncThen();
     void testSyncThen();
     void testJoinedThen();
+    void testVoidThen();
 
     void testAsyncEach();
     void testSyncEach();
     void testJoinedEach();
+    void testVoidEach();
 
     void testAsyncReduce();
     void testSyncReduce();
     void testJoinedReduce();
+    void testVoidReduce();
 
     void testErrorHandler();
 
-
     void testChainingRunningJob();
     void testChainingFinishedJob();
 
@@ -94,6 +96,30 @@ private:
 };
 
 
+template<>
+class AsyncTest::AsyncSimulator<void> {
+public:
+    AsyncSimulator(Async::Future<void> &future)
+        : mFuture(future)
+    {
+        QObject::connect(&mTimer, &QTimer::timeout,
+                            [this]() {
+                                mFuture.setFinished();
+                            });
+        QObject::connect(&mTimer, &QTimer::timeout,
+                            [this]() {
+                                delete this;
+                            });
+        mTimer.setSingleShot(true);
+        mTimer.start(200);
+    }
+
+private:
+    Async::Future<void> mFuture;
+    QTimer mTimer;
+};
+
+
 
 void AsyncTest::testSyncPromises()
 {
@@ -213,7 +239,8 @@ void AsyncTest::testSyncThen()
     auto job = Async::start<int>(
         []() -> int {
             return 42;
-        }).then<int, int>(
+        })
+    .then<int, int>(
         [](int in) -> int {
             return in * 2;
         });
@@ -243,6 +270,32 @@ void AsyncTest::testJoinedThen()
     QCOMPARE(future.value(), 84);
 }
 
+void AsyncTest::testVoidThen()
+{
+    int check = 0;
+
+    auto job = Async::start<void>(
+        [&check](Async::Future<void> &future) {
+            new AsyncSimulator<void>(future);
+            ++check;
+        })
+    .then<void>(
+        [&check](Async::Future<void> &future) {
+            new AsyncSimulator<void>(future);
+            ++check;
+        })
+    .then<void>(
+        [&check]() {
+            ++check;
+        });
+
+    auto future = job.exec();
+    future.waitForFinished();
+
+    QVERIFY(future.isFinished());
+    QCOMPARE(check, 3);
+}
+
 
 
 void AsyncTest::testAsyncEach()
@@ -303,6 +356,25 @@ void AsyncTest::testJoinedEach()
     QCOMPARE(future.value(), expected);
 }
 
+void AsyncTest::testVoidEach()
+{
+    QList<int> check;
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        }).each<void, int>(
+        [&check](const int &v) {
+            check << v;
+        });
+
+    auto future = job.exec();
+
+    const QList<int> expected({ 1, 2, 3, 4 });
+    QVERIFY(future.isFinished());
+    QCOMPARE(check, expected);
+}
+
+
 
 
 
@@ -377,6 +449,23 @@ void AsyncTest::testJoinedReduce()
     QCOMPARE(future.value(), 10);
 }
 
+void AsyncTest::testVoidReduce()
+{
+// This must not compile (reduce with void result makes no sense)
+#ifdef TEST_BUILD_FAIL
+    auto job = Async::start<QList<int>>(
+        []() -> QList<int> {
+            return { 1, 2, 3, 4 };
+        })
+    .reduce<void, QList<int>>(
+        [](const QList<int> &list) -> int {
+            return;
+        });
+
+    auto future = job.exec();
+    QVERIFY(future.isFinished());
+#endif
+}
 
 
 
@@ -471,8 +560,6 @@ void AsyncTest::testChainingFinishedJob()
 
 
 
-
-
 void AsyncTest::benchmarkSyncThenExecutor()
 {
     auto job = Async::start<int>(