corotasktest.cpp

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#include "corotasktest.h"
#include <QtConcurrentRun>
#include <QtTest>
#ifdef QT_DBUS_LIB
#include <QDBusInterface>
#endif
#include <coro/future.h>
#include <coro.h>
#include <coro/getresult.h>
#include <coro/inparallel.h>
#include <coro/sharedtask.h>
#include <coro/throttle.h>
#ifdef QT_DBUS_LIB
#include <coro/dbus.h>
#endif
#include <util/threads/futures.h>
#include <util/sll/debugprinters.h>
#include <util/sll/qtutil.h>
 
QTEST_GUILESS_MAIN (LC::Util::CoroTaskTest)
 
using namespace std::chrono_literals;
 
namespace LC::Util
{
    void CoroTaskTest::testReturn ()
    {
        auto task = [] () -> Task<int> { co_return 42; } ();
        auto result = GetTaskResult (task);
        QCOMPARE (result, 42);
    }
 
    void CoroTaskTest::testMoveOnlyReturn ()
    {
        auto direct = [] () -> Task<std::unique_ptr<int>>
        {
            co_return std::make_unique<int> (42);
        } ();
        auto directResult = GetTaskResult (direct);
        QVERIFY (directResult);
        QCOMPARE (*directResult, 42);
 
        auto chained = [] () -> Task<std::unique_ptr<int>>
        {
            auto inner = [] () -> Task<std::unique_ptr<int>>
            {
                co_await 5ms;
                co_return std::make_unique<int> (7);
            } ();
            auto value = co_await inner;
            *value *= 6;
            co_return std::move (value);
        } ();
        auto chainedResult = GetTaskResult (chained);
        QVERIFY (chainedResult);
        QCOMPARE (*chainedResult, 42);
    }
 
    void CoroTaskTest::testWait ()
    {
        QElapsedTimer timer;
        timer.start ();
 
        auto task = [] () -> Task<int>
        {
            co_await 50ms;
            co_await Precisely { 10ms };
            co_return 42;
        } ();
 
        auto result = GetTaskResult (task);
        QCOMPARE (result, 42);
        QCOMPARE_GT (timer.elapsed (), 50);
    }
 
    void CoroTaskTest::testTaskDestr ()
    {
        bool continued = false;
 
        [] (auto& continued) -> Task<void>
        {
            co_await 10ms;
            continued = true;
        } (continued);
 
        QTRY_VERIFY_WITH_TIMEOUT (continued, 20);
    }
 
    namespace
    {
        // almost the Public Morozov pattern
        class MockReply : public QNetworkReply
        {
            QBuffer Buffer_;
        public:
            using QNetworkReply::QNetworkReply;
 
            using QNetworkReply::setAttribute;
            using QNetworkReply::setError;
            using QNetworkReply::setFinished;
            using QNetworkReply::setHeader;
            using QNetworkReply::setOperation;
            using QNetworkReply::setRawHeader;
            using QNetworkReply::setRequest;
            using QNetworkReply::setUrl;
 
            void SetData (const QByteArray& data)
            {
                Buffer_.setData (data);
                Buffer_.open (QIODevice::ReadOnly);
                open (QIODevice::ReadOnly);
            }
        protected:
            qint64 readData (char *data, qint64 maxSize) override
            {
                return Buffer_.read (data, maxSize);
            }
 
            void abort () override
            {
            }
        };
 
        class MockNAM : public QNetworkAccessManager
        {
            QPointer<MockReply> Reply_;
        public:
            explicit MockNAM (MockReply *reply)
            : Reply_ { reply }
            {
            }
 
            MockReply* GetReply ()
            {
                return Reply_;
            }
        protected:
            QNetworkReply* createRequest (Operation op, const QNetworkRequest& req, QIODevice*) override
            {
                Reply_->setUrl (req.url ());
                Reply_->setOperation (op);
                Reply_->setRequest (req);
                return Reply_;
            }
        };
 
        auto MkSuccessfulReply (const QByteArray& data)
        {
            auto reply = new MockReply;
            reply->setAttribute (QNetworkRequest::HttpStatusCodeAttribute, 200);
            reply->SetData (data);
            return reply;
        }
 
        auto MkErrorReply ()
        {
            auto reply = new MockReply;
            reply->setAttribute (QNetworkRequest::HttpStatusCodeAttribute, 404);
            reply->setError (QNetworkReply::NetworkError::ContentAccessDenied, "well, 404!"_qs);
            return reply;
        }
 
        void TestGoodReply (auto finishMarker)
        {
            const QByteArray data { "this is some test data" };
            MockNAM nam { MkSuccessfulReply (data) };
            finishMarker (*nam.GetReply ());
 
            auto task = [&nam] () -> Task<QByteArray>
            {
                auto reply = co_await *nam.get (QNetworkRequest { QUrl { "http://example.com/foo.txt"_qs } });
                co_return reply.GetReplyData ();
            } ();
 
            auto result = GetTaskResult (task);
            QCOMPARE (result, data);
        }
 
        void TestBadReply (auto finishMarker)
        {
            MockNAM nam { MkErrorReply () };
            finishMarker (*nam.GetReply ());
 
            auto task = [&nam] () -> Task<QByteArray>
            {
                auto reply = co_await *nam.get (QNetworkRequest { QUrl { "http://example.com/foo.txt"_qs } });
                co_return reply.GetReplyData ();
            } ();
 
            QVERIFY_THROWS_EXCEPTION (LC::Util::NetworkReplyErrorException, GetTaskResult (task));
        }
 
        void ImmediateFinishMarker (MockReply& reply)
        {
            reply.setFinished (true);
        }
 
        void DelayedFinishMarker (MockReply& reply)
        {
            QTimer::singleShot (10ms,
                    [&]
                    {
                        reply.setFinished (true);
                        emit reply.finished ();
                    });
        }
    }
 
    void CoroTaskTest::testNetworkReplyGoodNoWait ()
    {
        TestGoodReply (&ImmediateFinishMarker);
    }
 
    void CoroTaskTest::testNetworkReplyGoodWait ()
    {
        TestGoodReply (&DelayedFinishMarker);
    }
 
    void CoroTaskTest::testNetworkReplyBadNoWait ()
    {
        TestBadReply (&ImmediateFinishMarker);
    }
 
    void CoroTaskTest::testNetworkReplyBadWait ()
    {
        TestBadReply (&DelayedFinishMarker);
    }
 
    void CoroTaskTest::testFutureAwaiter ()
    {
        auto delayed = [] () -> Task<int>
        {
            co_return co_await QtConcurrent::run ([]
                    {
                        QThread::msleep (1);
                        return 42;
                    });
        } ();
        QCOMPARE (GetTaskResult (delayed), 42);
 
        auto immediate = [] () -> Task<int>
        {
            co_return co_await QtConcurrent::run ([] { return 42; });
        } ();
        QCOMPARE (GetTaskResult (immediate), 42);
 
        auto ready = [] () -> Task<int>
        {
            co_return co_await MakeReadyFuture (42);
        } ();
        QCOMPARE (GetTaskResult (ready), 42);
    }
 
    void CoroTaskTest::testWaitMany ()
    {
        constexpr auto max = 100;
        auto mkTask = [] (int index) -> Task<int>
        {
            co_await Precisely { std::chrono::milliseconds { max - index } };
            co_return index;
        };
 
        QElapsedTimer timer;
        timer.start ();
        QVector<Task<int>> tasks;
        QVector<int> expected;
        for (int i = 0; i < max; ++i)
        {
            tasks << mkTask (i);
            expected << i;
        }
        const auto creationElapsed = timer.elapsed ();
 
        timer.restart ();
        auto result = GetTaskResult (InParallel (std::move (tasks)));
        const auto executionElapsed = timer.elapsed ();
 
        QCOMPARE (result, expected);
        QCOMPARE_LT (creationElapsed, 1);
 
        constexpr auto tolerance = 0.05;
        QCOMPARE_GE (executionElapsed, max * (1 - tolerance));
        const auto linearizedExecTime = max * (max + 1) / 2;
        QCOMPARE_LT (executionElapsed, linearizedExecTime / 2);
    }
 
    void CoroTaskTest::testWaitManyTuple ()
    {
        auto mkTask = [] (int delay) -> Task<int>
        {
            co_await Precisely { std::chrono::milliseconds { delay } };
            co_return delay;
        };
 
        QElapsedTimer timer;
        timer.start ();
        auto result = GetTaskResult (InParallel (mkTask (10), mkTask (9), mkTask (2), mkTask (1)));
        const auto executionElapsed = timer.elapsed ();
 
        QCOMPARE (result, (std::tuple { 10, 9, 2, 1 }));
 
        QCOMPARE_GE (executionElapsed, 10);
        QCOMPARE_LT (executionElapsed, (10 + 9 + 2 + 1) / 2);
    }
 
    void CoroTaskTest::testWaitManyInvoking ()
    {
        constexpr auto max = 100;
        auto mkTask = [] (int index) -> Task<int>
        {
            co_await Precisely { std::chrono::milliseconds { max - index } };
            co_return index;
        };
 
        QElapsedTimer timer;
        timer.start ();
        QVector<int> inputs;
        QVector<int> expected;
        for (int i = 0; i < max; ++i)
        {
            inputs << i;
            expected << i;
        }
        const auto creationElapsed = timer.elapsed ();
 
        timer.restart ();
        auto result = GetTaskResult (InParallel (inputs, mkTask));
        const auto executionElapsed = timer.elapsed ();
 
        QCOMPARE (result, expected);
        QCOMPARE_LT (creationElapsed, 1);
 
        constexpr auto tolerance = 0.05;
        QCOMPARE_GE (executionElapsed, max * (1 - tolerance));
        const auto linearizedExecTime = max * (max + 1) / 2;
        QCOMPARE_LT (executionElapsed, linearizedExecTime / 2);
    }
 
    void CoroTaskTest::testSharedTaskManyAwaiters ()
    {
        auto shared = [] () -> SharedTask<int>
        {
            co_await 10ms;
            co_return 42;
        } ();
 
        auto mkAwaiter = [&shared] (int offset) -> Task<int>
        {
            co_return co_await shared + offset;
        };
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (0), mkAwaiter (1)));
        QCOMPARE (result, (std::tuple { 42, 43 }));
    }
 
    void CoroTaskTest::testSharedTaskAwaiterRemovedOnOuterDestruction ()
    {
        constexpr auto destructionDelay = 10ms;
        auto shared = [] () -> SharedTask<int>
        {
            co_await 500ms;
            co_return 42;
        } ();
 
        auto survivingAwaiter = [&shared] () -> Task<int>
        {
            co_return co_await shared;
        } ();
 
        auto context = std::make_unique<QObject> ();
        auto cancelledAwaiter = [&shared] (QObject *context) -> ContextTask<int>
        {
            co_await AddContextObject { *context };
            co_return co_await shared;
        } (&*context);
        QTimer::singleShot (destructionDelay, [context = std::move (context)] () mutable { context.reset (); });
 
        QCOMPARE (GetTaskResult (survivingAwaiter), 42);
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (cancelledAwaiter));
    }
 
    void CoroTaskTest::testSharedTaskExceptionManyAwaiters ()
    {
        struct TestSharedTaskException : std::exception {};
 
        auto shared = [] () -> SharedTask<>
        {
            co_await 10ms;
            throw TestSharedTaskException {};
        } ();
 
        auto mkAwaiter = [&shared] () -> Task<bool>
        {
            try
            {
                co_await shared;
                co_return false;
            }
            catch (const TestSharedTaskException&)
            {
                co_return true;
            }
        };
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (), mkAwaiter ()));
        QCOMPARE (result, (std::tuple { true, true }));
    }
 
    void CoroTaskTest::testSharedTaskLastCopyDestroyedByAwaiter ()
    {
        std::optional<SharedTask<int>> shared = [] () -> SharedTask<int>
        {
            co_await 10ms;
            co_return 42;
        } ();
 
        auto destructiveAwaiter = [] (std::optional<SharedTask<int>> *shared) -> Task<int>
        {
            auto result = co_await **shared;
            shared->reset ();
            co_return result;
        } (&shared);
 
        auto normalAwaiter = [] (std::optional<SharedTask<int>> *shared) -> Task<int>
        {
            co_return co_await **shared;
        } (&shared);
 
        const auto result = GetTaskResult (InParallel (destructiveAwaiter, normalAwaiter));
        QCOMPARE (result, (std::tuple { 42, 42 }));
    }
 
    void CoroTaskTest::testSharedTaskNonTriviallyMovableReturn ()
    {
        // Long enough that a moved-from QString is different from the real one, avoiding any SSO shenanigans.
        const auto payload = "0123456789abcdef"_qs.repeated (16);
 
        auto shared = [] (QString p) -> SharedTask<QString>
        {
            co_await 10ms;
            co_return p;
        } (payload);
 
        auto mkAwaiter = [&shared] () -> Task<QString>
        {
            co_return co_await shared;
        };
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (), mkAwaiter ()));
        QCOMPARE (result, (std::tuple { payload, payload }));
    }
 
    void CoroTaskTest::testSharedContextTaskManyAwaitersContextAlive ()
    {
        auto context = std::make_unique<QObject> ();
        auto shared = [] (QObject *ctx) -> SharedContextTask<int>
        {
            co_await AddContextObject { *ctx };
            co_await 10ms;
            co_return 42;
        } (&*context);
 
        auto mkAwaiter = [&shared] (int offset) -> Task<int>
        {
            co_return co_await shared + offset;
        };
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (0), mkAwaiter (1)));
        QCOMPARE (result, (std::tuple { 42, 43 }));
    }
 
    void CoroTaskTest::testSharedContextTaskContextDeadFansOutToAll ()
    {
        auto context = std::make_unique<QObject> ();
        auto shared = [] (QObject *ctx) -> SharedContextTask<int>
        {
            co_await AddContextObject { *ctx };
            co_await 500ms;
            co_return 42;
        } (&*context);
 
        auto mkAwaiter = [&shared] () -> Task<bool>
        {
            try
            {
                co_await shared;
                co_return false;
            }
            catch (const ContextDeadException&)
            {
                co_return true;
            }
        };
 
        QTimer::singleShot (10ms, [context = std::move (context)] () mutable { context.reset (); });
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (), mkAwaiter ()));
        QCOMPARE (result, (std::tuple { true, true }));
    }
 
    void CoroTaskTest::testSharedContextTaskBodyExceptionFansOut ()
    {
        struct TestSharedContextException : std::exception {};
 
        auto context = std::make_unique<QObject> ();
        auto shared = [] (QObject *ctx) -> SharedContextTask<>
        {
            co_await AddContextObject { *ctx };
            co_await 10ms;
            throw TestSharedContextException {};
        } (&*context);
 
        auto mkAwaiter = [&shared] () -> Task<bool>
        {
            try
            {
                co_await shared;
                co_return false;
            }
            catch (const TestSharedContextException&)
            {
                co_return true;
            }
        };
 
        const auto result = GetTaskResult (InParallel (mkAwaiter (), mkAwaiter ()));
        QCOMPARE (result, (std::tuple { true, true }));
    }
 
    void CoroTaskTest::testSharedContextTaskContextDeadDoesntWaitLong ()
    {
        auto context = std::make_unique<QObject> ();
        auto shared = [] (QObject *ctx) -> SharedContextTask<>
        {
            co_await AddContextObject { *ctx };
            co_await 500ms;
        } (&*context);
 
        auto awaiter = [&shared] () -> Task<void>
        {
            co_await shared;
        } ();
 
        QTimer::singleShot (10ms, [context = std::move (context)] () mutable { context.reset (); });
 
        QElapsedTimer timer;
        timer.start ();
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (awaiter));
        QCOMPARE_LT (timer.elapsed (), 255);
    }
 
    void CoroTaskTest::testSharedContextTaskMixedAwaitersOwnContextDies ()
    {
        auto sharedCtx = std::make_unique<QObject> ();
        auto aliveCtx = std::make_unique<QObject> ();
        auto dyingCtx = std::make_unique<QObject> ();
 
        auto shared = [] (QObject *ctx) -> SharedContextTask<int>
        {
            co_await AddContextObject { *ctx };
            co_await 100ms;
            co_return 42;
        } (&*sharedCtx);
 
        auto aliveAwaiter = [&shared] (QObject *ctx) -> ContextTask<int>
        {
            co_await AddContextObject { *ctx };
            co_return co_await shared;
        } (&*aliveCtx);
 
        auto dyingAwaiter = [&shared] (QObject *ctx) -> ContextTask<int>
        {
            co_await AddContextObject { *ctx };
            co_return co_await shared;
        } (&*dyingCtx);
 
        QTimer::singleShot (10ms, [dyingCtx = std::move (dyingCtx)] () mutable { dyingCtx.reset (); });
 
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (dyingAwaiter));
        QCOMPARE (GetTaskResult (aliveAwaiter), 42);
    }
 
    void CoroTaskTest::testEither ()
    {
        using Result_t = Either<QString, bool>;
 
        auto immediatelyFailing = [] () -> Task<Result_t>
        {
            const auto theInt = co_await Either<QString, int> { "meh" };
            co_return theInt > 420;
        } ();
        QCOMPARE (GetTaskResult (immediatelyFailing), Result_t { Left { "meh" } });
 
        auto earlyFailing = [] () -> Task<Result_t>
        {
            const auto theInt = co_await Either<QString, int> { "meh" };
            co_await 10ms;
            co_return theInt > 420;
        } ();
        QCOMPARE (GetTaskResult (earlyFailing), Result_t { Left { "meh" } });
 
        auto successful = [] () -> Task<Result_t>
        {
            const auto theInt = co_await Either<QString, int> { 42 };
            co_await 10ms;
            co_return theInt > 420;
        } ();
        QCOMPARE (GetTaskResult (successful), Result_t { false });
    }
 
    void CoroTaskTest::testEitherIgnoreLeft ()
    {
        auto immediatelyFailing = [] () -> Task<Either<QString, int>>
        {
            const auto theInt = co_await WithHandler (Either<QString, int> { "meh" }, IgnoreLeft {});
            co_return theInt;
        } ();
        QCOMPARE (GetTaskResult (immediatelyFailing), (Either<QString, int> { 0 }));
    }
 
    void CoroTaskTest::testThrottleSameCoro ()
    {
        Throttle t { 10ms };
        constexpr auto count = 10;
 
        QElapsedTimer timer;
        timer.start ();
        auto task = [] (auto& t) -> Task<int>
        {
            int result = 0;
            for (int i = 0; i < count; ++i)
            {
                co_await t;
                result += i;
            }
            co_return result;
        } (t);
        const auto result = GetTaskResult (task);
        const auto time = timer.elapsed ();
 
        QCOMPARE (result, count * (count - 1) / 2);
        QCOMPARE_GE (time, count * t.GetInterval ().count ());
    }
 
    void CoroTaskTest::testThrottleSameCoroSlow ()
    {
        Throttle t { 10ms };
        constexpr auto count = 10;
        constexpr static auto intraDelay = 9ms;
 
        QElapsedTimer timer;
        timer.start ();
        auto task = [] (auto& t) -> Task<void>
        {
            for (int i = 0; i < count; ++i)
            {
                co_await t;
                if (i != count - 1)
                    co_await Precisely { intraDelay };
            }
        } (t);
        GetTaskResult (task);
        const auto time = timer.elapsed ();
 
        const auto expectedMinTime = count * t.GetInterval ().count ();
        QCOMPARE_GE (time, expectedMinTime);
 
        const auto delaysTime = (count - 1) * intraDelay.count ();
        QCOMPARE_LE (time - expectedMinTime, delaysTime / 2);
    }
 
    void CoroTaskTest::testThrottleSameCoroVerySlow ()
    {
        Throttle t { 10ms };
        constexpr auto count = 10;
        constexpr static auto intraDelay = 20ms;
 
        QElapsedTimer timer;
        timer.start ();
        auto task = [] (auto& t) -> Task<void>
        {
            for (int i = 0; i < count; ++i)
            {
                co_await t;
                if (i != count - 1)
                    co_await Precisely { intraDelay };
            }
        } (t);
        GetTaskResult (task);
        const auto time = timer.elapsed ();
 
        const auto expectedMinTime = (count - 1) * intraDelay.count ();
        QCOMPARE_GE (time, expectedMinTime);
 
        const auto throttlesTime = count * t.GetInterval ().count ();
        QCOMPARE_LE (time - expectedMinTime, throttlesTime / 2);
    }
 
    void CoroTaskTest::testThrottleManyCoros ()
    {
        Throttle t { 1ms, Qt::TimerType::PreciseTimer };
        constexpr auto count = 10;
 
        QElapsedTimer timer;
        timer.start ();
        auto mkTask = [] (auto& t) -> Task<void>
        {
            for (int i = 0; i < count; ++i)
                co_await t;
        };
        QVector tasks { mkTask (t), mkTask (t), mkTask (t) };
        for (auto& task : tasks)
            GetTaskResult (task);
        const auto time = timer.elapsed ();
 
        QCOMPARE_GE (time, count * tasks.size () * t.GetInterval ().count ());
    }
 
    constexpr auto LongDelay = 500ms;
    constexpr auto ShortDelay = 10ms;
    constexpr auto DelayThreshold = std::chrono::duration_cast<std::chrono::milliseconds> ((ShortDelay + LongDelay) / 2);
 
    void CoroTaskTest::testContextDestrBeforeFinish ()
    {
        auto context = std::make_unique<QObject> ();
        auto task = [] (QObject *context) -> ContextTask<int>
        {
            co_await AddContextObject { *context };
            co_await LongDelay;
            co_return context->children ().size ();
        } (&*context);
        context.reset ();
 
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (task));
    }
 
    void CoroTaskTest::testContextDestrAfterFinish ()
    {
        auto context = std::make_unique<QObject> ();
        auto task = [] (QObject *context) -> ContextTask<int>
        {
            co_await AddContextObject { *context };
            co_await ShortDelay;
            co_return context->children ().size ();
        } (&*context);
 
        QCOMPARE (GetTaskResult (task), 0);
    }
 
    void CoroTaskTest::testContextDestrAwaitedSubtask ()
    {
        auto context = std::make_unique<QObject> ();
        auto task = [] (QObject *context) -> ContextTask<int>
        {
            co_await AddContextObject { *context };
 
            const auto nestedSubtask = [] -> ContextTask<int>
            {
                co_await ShortDelay;
                co_return 42;
            } ();
 
            co_await nestedSubtask;
            co_return context->children ().size ();
        } (&*context);
        context.reset ();
 
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (task));
    }
 
    namespace
    {
        template<typename... Ts>
        auto WithContext (auto&& taskGen, Ts&&... taskArgs)
        {
            auto context = std::make_unique<QObject> ();
            auto task = taskGen (&*context, std::forward<Ts> (taskArgs)...);
            QTimer::singleShot (ShortDelay, [context = std::move (context)] () mutable { context.reset (); });
            return task;
        }
 
        void WithDestroyTimer (auto task)
        {
            QElapsedTimer timer;
            timer.start ();
            QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (task));
            QCOMPARE_LT (timer.elapsed (), DelayThreshold.count ());
        }
    }
 
    void CoroTaskTest::testContextDestrDoesntWaitTimer ()
    {
        WithDestroyTimer (WithContext ([] (QObject *context) -> ContextTask<void>
                {
                    co_await AddContextObject { *context };
                    co_await LongDelay;
                }));
    }
 
    void CoroTaskTest::testContextDestrDoesntWaitNetwork ()
    {
        const QByteArray data { "this is some test data" };
        auto nam = std::make_shared<MockNAM> (MkSuccessfulReply (data));
        QTimer::singleShot (LongDelay,
                [nam]
                {
                    if (const auto reply = nam->GetReply ())
                    {
                        reply->setFinished (true);
                        emit reply->finished ();
                    }
                });
 
        WithDestroyTimer (WithContext ([] (QObject *context, QNetworkAccessManager *nam) -> ContextTask<QByteArray>
                {
                    co_await AddContextObject { *context };
                    const auto reply = co_await *nam->get (QNetworkRequest { QUrl { "http://example.com/foo.txt"_qs } });
                    co_return reply.GetReplyData ();
                }, &*nam));
    }
 
    void CoroTaskTest::testContextDestrDoesntWaitProcess ()
    {
        WithDestroyTimer (WithContext ([] (QObject *context) -> ContextTask<>
                {
                    co_await AddContextObject { *context };
 
                    const auto process = new QProcess {};
                    const auto delay = std::chrono::duration_cast<std::chrono::milliseconds> (LongDelay);
                    process->start ("sleep", { QString::number (delay.count () / 1000.0) });
                    connect (process,
                            &QProcess::finished,
                            process,
                            &QObject::deleteLater);
 
                    co_await *process;
                }));
    }
 
    void CoroTaskTest::testContextDestrDoesntWaitFuture ()
    {
        WithDestroyTimer (WithContext ([] (QObject *context) -> ContextTask<>
                {
                    co_await AddContextObject { *context };
                    co_await QtConcurrent::run ([] { QThread::sleep (LongDelay); });
                }));
    }
 
#ifdef QT_DBUS_LIB
    void CoroTaskTest::testDBus ()
    {
        const auto& bus = QDBusConnection::systemBus ();
        if (!bus.isConnected ())
            QSKIP ("D-Bus system bus is not available");
 
        auto task = [] () -> Task<Either<QDBusError::ErrorType, bool>>
        {
            const auto& bus = QDBusConnection::systemBus ();
            QDBusInterface dbusIface { "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", bus };
            const auto result = co_await Typed<bool> (dbusIface.asyncCall ("NameHasOwner", "org.freedesktop.DBus"_qs));
            co_return result.MapLeft (&QDBusError::type);
        } ();
 
        QCOMPARE (GetTaskResult (task), true);
    }
#endif
 
    void CoroTaskTest::cleanupTestCase ()
    {
        bool done = false;
        QTimer::singleShot (LongDelay * 2, [&done] { done = true; });
        QTRY_VERIFY (done);
    }
}