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 <algorithm>
#include <csignal>
#include <functional>
#include <stdexcept>
#include <string>
#include <thread>
#include <variant>
#include <QProcess>
#include <QProcessEnvironment>
#include <QRegularExpression>
#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>
#include <util/sll/util.h>
 
using Scenario = std::function<void ()>;
Q_DECLARE_METATYPE (Scenario)
 
QTEST_GUILESS_MAIN (LC::Util::CoroTaskTest)
 
using namespace std::chrono_literals;
 
namespace LC::Util
{
    namespace
    {
        constexpr auto TimerTolerance = 0.05;
 
        constexpr auto MinElapsed (std::chrono::milliseconds expected)
        {
            return expected.count () * (1 - TimerTolerance);
        }
    }
 
    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);
 
        QCOMPARE_GE (executionElapsed, MinElapsed (max * 1ms));
        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);
 
        QCOMPARE_GE (executionElapsed, MinElapsed (max * 1ms));
        const auto linearizedExecTime = max * (max + 1) / 2;
        QCOMPARE_LT (executionElapsed, linearizedExecTime / 2);
    }
 
    void CoroTaskTest::testNCopies ()
    {
        constexpr auto count = 10;
        static constexpr auto unit = 10ms;
 
        auto mkTask = [] (int index) -> Task<int>
        {
            co_await Precisely { unit * (count - index) };
            co_return index;
        };
 
        int created = 0;
        QElapsedTimer timer;
        timer.start ();
        auto task = NCopies (count, [&] { return mkTask (created++); });
        const auto creationElapsed = timer.elapsed ();
 
        static_assert (std::is_same_v<decltype (task), Task<QVector<int>>>);
        QCOMPARE (created, count);
        QCOMPARE_LT (creationElapsed, unit.count ());
 
        timer.restart ();
        const auto result = GetTaskResult (task);
        const auto executionElapsed = timer.elapsed ();
 
        QVector<int> expected;
        for (int i = 0; i < count; ++i)
            expected << i;
        QCOMPARE (result, expected);
 
        QCOMPARE_GE (executionElapsed, MinElapsed (count * unit));
        const auto linearizedExecTime = unit.count () * count * (count + 1) / 2;
        QCOMPARE_LT (executionElapsed, linearizedExecTime / 2);
    }
 
    void CoroTaskTest::testNCopiesVoid ()
    {
        constexpr auto count = 5;
        auto mkTask = [] (int& finished) -> Task<void>
        {
            co_await 10ms;
            ++finished;
        };
 
        int finished = 0;
        auto task = NCopies (count, [&] { return mkTask (finished); });
        static_assert (std::is_same_v<decltype (task), Task<void>>);
        QCOMPARE (finished, 0);
 
        GetTaskResult (task);
        QCOMPARE (finished, count);
 
        [[maybe_unused]] auto mkContextTask = [] () -> ContextTask<void> { co_return; };
        static_assert (std::is_same_v<decltype (NCopies (1, mkContextTask)), ContextTask<void>>,
                "extensions did not survive the delegation");
    }
 
    void CoroTaskTest::testNCopiesZero ()
    {
        int created = 0;
        auto mkTask = [] (int& created) -> Task<int>
        {
            ++created;
            co_return 0;
        };
 
        const auto result = GetTaskResult (NCopies (0, [&] { return mkTask (created); }));
        QVERIFY (result.isEmpty ());
        QCOMPARE (created, 0);
    }
 
    namespace
    {
        Task<int> SlowSuccess (std::chrono::milliseconds delay, bool& done)
        {
            co_await Precisely { delay };
            done = true;
            co_return 0;
        }
 
        Task<int> SlowFailure (std::chrono::milliseconds delay, std::string what)
        {
            co_await Precisely { delay };
            throw std::runtime_error { what };
        }
 
        QString ThrownMessage (auto&& f)
        {
            try
            {
                f ();
            }
            catch (const std::exception& e)
            {
                return QString::fromUtf8 (e.what ());
            }
            return {};
        }
    }
 
    void CoroTaskTest::testWaitManyJoinsAfterFailure ()
    {
        constexpr auto slowDelay = 60ms;
        bool slowDone = false;
        QElapsedTimer timer;
        timer.start ();
        const auto message = ThrownMessage ([&] { GetTaskResult (InParallel ({ SlowFailure (10ms, "early"), SlowSuccess (slowDelay, slowDone) })); });
        const auto elapsed = timer.elapsed ();
 
        QCOMPARE (message, "early"_qs);
        QVERIFY (slowDone);
        QCOMPARE_GE (elapsed, MinElapsed (slowDelay));
    }
 
    void CoroTaskTest::testWaitManyVoidJoinsAfterFailure ()
    {
        auto slowSuccess = [] (bool& done) -> Task<void>
        {
            co_await Precisely { 50ms };
            done = true;
        };
        auto earlyFailure = [] () -> Task<void>
        {
            co_await Precisely { 5ms };
            throw std::runtime_error { "early" };
        };
 
        bool slowDone = false;
        const auto message = ThrownMessage ([&] { GetTaskResult (InParallel ({ earlyFailure (), slowSuccess (slowDone) })); });
        QCOMPARE (message, "early"_qs);
        QVERIFY (slowDone);
    }
 
    void CoroTaskTest::testWaitManyFirstFailureInOrderWins ()
    {
        QTest::ignoreMessage (QtWarningMsg, "dropping a subsequent exception: first in time");
 
        const auto message = ThrownMessage ([] { GetTaskResult (InParallel ({ SlowFailure (40ms, "first in order"), SlowFailure (10ms, "first in time") })); });
        QCOMPARE (message, "first in order"_qs);
    }
 
    void CoroTaskTest::testWaitManyInvokingFactoryThrows ()
    {
        constexpr auto delay = 40ms;
        QVector<bool> done (5, false);
        int created = 0;
        auto mkTask = [&] (int index)
        {
            if (index == 2)
                throw std::runtime_error { "factory" };
            ++created;
            return SlowSuccess (delay, done [index]);
        };
 
        QElapsedTimer timer;
        timer.start ();
        const auto message = ThrownMessage ([&] { GetTaskResult (InParallel (QVector { 0, 1, 2, 3, 4 }, mkTask)); });
        const auto elapsed = timer.elapsed ();
 
        QCOMPARE (message, "factory"_qs);
        QCOMPARE (created, 2);
        QCOMPARE (done, (QVector { true, true, false, false, false }));
        QCOMPARE_GE (elapsed, MinElapsed (delay));
    }
 
    void CoroTaskTest::testNCopiesFactoryThrows ()
    {
        bool done = false;
        int calls = 0;
        auto taskFactory = [&]
        {
            if (calls++ == 1)
                throw std::runtime_error { "factory" };
            return SlowSuccess (30ms, done);
        };
 
        const auto message = ThrownMessage ([&] { GetTaskResult (NCopies (3, taskFactory)); });
        QCOMPARE (message, "factory"_qs);
        QCOMPARE (calls, 2);
        QVERIFY (done);
    }
 
    void CoroTaskTest::testWaitManyContextDeathSilenced ()
    {
        QTest::failOnWarning (QRegularExpression { "dropping a subsequent"_qs });
 
        auto context = std::make_unique<CoroContext> ();
        auto mkTask = [] (CoroContext *context) -> ContextTask<void>
        {
            co_await AddContext { *context };
            co_await 500ms;
        };
        auto task = InParallel ({ mkTask (context.get ()), mkTask (context.get ()), mkTask (context.get ()) });
        QTimer::singleShot (10ms, [context = std::move (context)] () mutable { context.reset (); });
 
        QElapsedTimer timer;
        timer.start ();
        QVERIFY_THROWS_EXCEPTION (ContextDeadException, GetTaskResult (task));
        QCOMPARE_LT (timer.elapsed (), 250);
    }
 
    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<CoroContext> ();
        auto cancelledAwaiter = [&shared] (CoroContext *context) -> ContextTask<int>
        {
            co_await AddContext { *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<CoroContext> ();
        auto shared = [] (CoroContext *ctx) -> SharedContextTask<int>
        {
            co_await AddContext { *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<CoroContext> ();
        auto shared = [] (CoroContext *ctx) -> SharedContextTask<int>
        {
            co_await AddContext { *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<CoroContext> ();
        auto shared = [] (CoroContext *ctx) -> SharedContextTask<>
        {
            co_await AddContext { *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<CoroContext> ();
        auto shared = [] (CoroContext *ctx) -> SharedContextTask<>
        {
            co_await AddContext { *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<CoroContext> ();
        auto aliveCtx = std::make_unique<CoroContext> ();
        auto dyingCtx = std::make_unique<CoroContext> ();
 
        auto shared = [] (CoroContext *ctx) -> SharedContextTask<int>
        {
            co_await AddContext { *ctx };
            co_await 100ms;
            co_return 42;
        } (&*sharedCtx);
 
        auto aliveAwaiter = [&shared] (CoroContext *ctx) -> ContextTask<int>
        {
            co_await AddContext { *ctx };
            co_return co_await shared;
        } (&*aliveCtx);
 
        auto dyingAwaiter = [&shared] (CoroContext *ctx) -> ContextTask<int>
        {
            co_await AddContext { *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<CoroContext> ();
        auto task = [] (CoroContext *context) -> ContextTask<QString>
        {
            co_await AddContext { *context };
            co_await LongDelay;
            co_return context->GetName ();
        } (&*context);
        context.reset ();
 
        QVERIFY_THROWS_EXCEPTION (LC::Util::ContextDeadException, GetTaskResult (task));
    }
 
    void CoroTaskTest::testContextDestrAfterFinish ()
    {
        const auto ctxName = "some name"_qs;
        auto context = std::make_unique<CoroContext> (ctxName);
        auto task = [] (CoroContext *context) -> ContextTask<QString>
        {
            co_await AddContext { *context };
            co_await ShortDelay;
            co_return context->GetName ();
        } (&*context);
 
        QCOMPARE (GetTaskResult (task), ctxName);
    }
 
    void CoroTaskTest::testContextDestrAwaitedSubtask ()
    {
        auto context = std::make_unique<CoroContext> ();
        auto task = [] (CoroContext *context) -> ContextTask<QString>
        {
            co_await AddContext { *context };
 
            const auto nestedSubtask = [] -> ContextTask<int>
            {
                co_await ShortDelay;
                co_return 42;
            } ();
 
            co_await nestedSubtask;
            co_return context->GetName ();
        } (&*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<CoroContext> ();
            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 ([] (CoroContext *context) -> ContextTask<void>
                {
                    co_await AddContext { *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 ([] (CoroContext *context, QNetworkAccessManager *nam) -> ContextTask<QByteArray>
                {
                    co_await AddContext { *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 ([] (CoroContext *context) -> ContextTask<>
                {
                    co_await AddContext { *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 ([] (CoroContext *context) -> ContextTask<>
                {
                    co_await AddContext { *context };
                    co_await QtConcurrent::run ([] { QThread::sleep (LongDelay); });
                }));
    }
 
    void CoroTaskTest::testContextDestrDoesntWaitPlainTask ()
    {
        // a plain Task child is parked, not running: the parent is cancelled now and the child detached
        WithDestroyTimer (WithContext ([] (CoroContext *context) -> ContextTask<void>
                {
                    co_await AddContext { *context };
                    co_await [] () -> Task<void> { co_await LongDelay; } ();
                }));
    }
 
    namespace
    {
        using Event = CoroTaskTest::Event;
    }
 
    void CoroTaskTest::testContextDestrParentOutlivesChild ()
    {
        QList<Event> destrLog;
        auto task = WithContext ([] (CoroContext *context, QList<Event>& log) -> ContextTask<void>
                {
                    co_await AddContext { *context };
                    const auto cleanup = MakeScopeGuard ([&log] { log << Event::Parent; });
                    co_await [] (CoroContext *context, QList<Event>& log) -> ContextTask<void>
                    {
                        const auto childCleanup = MakeScopeGuard ([&log] { log << Event::Child; });
                        co_await AddContext { *context };
                        co_await LongDelay;
                    } (context, log);
                }, destrLog);
        WithDestroyTimer (task);
 
        QCOMPARE (destrLog, (QList { Event::Child, Event::Parent }));
    }
 
    void CoroTaskTest::testContextDestrDoesntResumeFinishedSibling ()
    {
        QList<Event> log;
        auto task = WithContext ([] (CoroContext *context, QList<Event>& log) -> ContextTask<void>
                {
                    co_await AddContext { *context };
                    const auto cleanup = MakeScopeGuard ([&log] { log << Event::Parent; });
 
                    auto child = [] (CoroContext *context, QList<Event>& log, std::chrono::milliseconds delay, Event name) -> ContextTask<void>
                    {
                        const auto cleanup = MakeScopeGuard ([&log, name] { log << name; });
                        co_await AddContext { *context };
                        co_await delay;
                    };
                    co_await InParallel ({ child (context, log, 1ms, Event::FastChild), child (context, log, LongDelay, Event::SlowChild) });
                }, log);
        WithDestroyTimer (task);
 
        std::ranges::sort (log);    // threat the log as a set and ensure it contains all expected events
        QCOMPARE (log, (QList { Event::Parent, Event::FastChild, Event::SlowChild }));
    }
 
    namespace
    {
        struct TouchRecordingAwaiter
        {
            bool& Touched_;
 
            bool await_ready () noexcept
            {
                Touched_ = true;
                return true;
            }
 
            void await_suspend (std::coroutine_handle<>) noexcept {}
            void await_resume () noexcept {}
        };
    }
 
    void CoroTaskTest::testContextDestrSwallowedDoesntTouchNextAwaitable ()
    {
        bool touched = false;
        auto task = WithContext ([] (CoroContext *context, bool& touched) -> ContextTask<void>
                {
                    co_await AddContext { *context };
                    try
                    {
                        co_await LongDelay;
                    }
                    catch (const std::exception&)
                    {
                    }
                    co_await TouchRecordingAwaiter { touched }; // the retry delay
                }, touched);
        WithDestroyTimer (task);
        QVERIFY (!touched);
    }
 
    namespace
    {
        using Context_ptr = std::unique_ptr<CoroContext>;
 
        ContextTask<void> DestroyingChild (Context_ptr& context)
        {
            co_await AddContext { *context };
            co_await ShortDelay;
            context.reset ();
        }
 
        ContextTask<void> ImmediateDestroyingChild (Context_ptr& context)
        {
            co_await AddContext { *context };
            context.reset ();   // the frame has never suspended at this point
        }
 
        ContextTask<void> SleepingChild (Context_ptr& context)
        {
            co_await AddContext { *context };
            co_await LongDelay;
        }
 
        Task<void> PlainMiddle (Context_ptr& context)
        {
            co_await DestroyingChild (context);
        }
 
        auto ParallelChildren (Context_ptr& context)
        {
            return InParallel ({ DestroyingChild (context), SleepingChild (context) });
        }
 
        ContextTask<void> Parent (Context_ptr& context, auto mkChild)
        {
            co_await AddContext { *context };
            co_await mkChild (context);
        }
 
        // runs the coro to completion, whichever way it ends
        void RunCoro (auto mkTask)
        {
            auto context = std::make_unique<CoroContext> ("doomed"_qs);
            GetTaskResult (mkTask (context));
        }
 
        void RunUnderParent (auto mkChild)
        {
            RunCoro ([&] (Context_ptr& context) { return Parent (context, mkChild); });
        }
 
        constexpr auto DeathChildEnvVar = "LC_COROTASKTEST_DEATH_CHILD";
 
        // gtest's "threadsafe" death test: the scenario runs in a fresh copy of this test binary invoked
        // for just the current test function (and data row), which is expected to die with the given message
        void ExpectFatal (const QString& message, auto scenario)
        {
            if (qEnvironmentVariableIsSet (DeathChildEnvVar))
            {
                scenario ();
                QFAIL ("the scenario was expected to abort");
            }
 
            auto testName = QString::fromLatin1 (QTest::currentTestFunction ());
            if (const auto tag = QTest::currentDataTag ())
                testName += ':' + QString::fromLatin1 (tag);
 
            auto env = QProcessEnvironment::systemEnvironment ();
            env.insert (DeathChildEnvVar, "1"_qs);
 
            QProcess child;
            child.setProcessEnvironment (env);
            child.setProcessChannelMode (QProcess::MergedChannels);
            child.start (QCoreApplication::applicationFilePath (), { "-nocrashhandler"_qs, testName });
            QVERIFY (child.waitForFinished ());
 
            const auto output = QString::fromUtf8 (child.readAll ());
            QVERIFY2 (child.exitStatus () == QProcess::CrashExit, qPrintable (output));
            QVERIFY2 (output.contains (message), qPrintable (output));
        }
    }
 
    void CoroTaskTest::testContextDestrFromRunningCoroAborts_data ()
    {
        QTest::addColumn<Scenario> ("scenario");
 
        QTest::newRow ("self") << Scenario { [] { RunCoro (&DestroyingChild); } };
        QTest::newRow ("child") << Scenario { [] { RunUnderParent (&DestroyingChild); } };
        QTest::newRow ("child via plain task") << Scenario { [] { RunUnderParent (&PlainMiddle); } };
        QTest::newRow ("child before first await") << Scenario { [] { RunUnderParent (&ImmediateDestroyingChild); } };
        QTest::newRow ("child in InParallel") << Scenario { [] { RunUnderParent (&ParallelChildren); } };
    }
 
    void CoroTaskTest::testContextDestrFromRunningCoroAborts ()
    {
        QFETCH (const Scenario, scenario);
        ExpectFatal ("destroying the context \"doomed\" while its child coro is running"_qs, scenario);
    }
 
    void CoroTaskTest::testContextOfIsPerObject ()
    {
        QObject first;
        QObject second;
        QVERIFY (&CoroContext::Of (first) == &CoroContext::Of (first));
        QVERIFY (&CoroContext::Of (first) != &CoroContext::Of (second));
    }
 
    void CoroTaskTest::testContextOfDiesWithObject ()
    {
        auto object = std::make_unique<QObject> ();
        auto task = [] (QObject *object) -> ContextTask<void>
        {
            co_await AddContext { CoroContext::Of (*object) };
            co_await LongDelay;
        } (object.get ());
        QTimer::singleShot (ShortDelay, [object = std::move (object)] () mutable { object.reset (); });
        WithDestroyTimer (task);
    }
 
    void CoroTaskTest::testContextOfRejectsForeignThread ()
    {
        QObject object;
        bool thrown = false;
        // a real thread: QtConcurrent::run () + result () may steal the runnable and run it right here
        std::thread { [&]
                {
                    try
                    {
                        CoroContext::Of (object);
                    }
                    catch (const std::runtime_error&)
                    {
                        thrown = true;
                    }
                } }.join ();
        QVERIFY (thrown);
        QVERIFY (&CoroContext::Of (object) == &CoroContext::Of (object));
    }
 
    namespace
    {
        Task<ProcessOutcome> RunProcess (QString program, QStringList args)
        {
            QProcess process;
            process.start (program, args);
            co_return co_await process;
        }
    }
 
    void CoroTaskTest::testProcessOutcomeExited ()
    {
        const auto outcome = GetTaskResult (RunProcess ("sh"_qs, { "-c"_qs, "exit 3"_qs }));
        QVERIFY (std::holds_alternative<ProcessExited> (outcome));
        QCOMPARE (std::get<ProcessExited> (outcome).Code_, 3);
    }
 
    void CoroTaskTest::testProcessOutcomeFailedToStart ()
    {
        const auto outcome = GetTaskResult (RunProcess ("lc-definitely-not-an-existing-binary"_qs, {}));
        QVERIFY (std::holds_alternative<ProcessFailedToStart> (outcome));
        QVERIFY (!std::get<ProcessFailedToStart> (outcome).Error_.isEmpty ());
    }
 
#ifdef Q_OS_UNIX
    void CoroTaskTest::testProcessOutcomeCrashed ()
    {
        const auto outcome = GetTaskResult (RunProcess ("sh"_qs, { "-c"_qs, "kill -SEGV $$"_qs }));
        QVERIFY (std::holds_alternative<ProcessCrashed> (outcome));
        QCOMPARE (std::get<ProcessCrashed> (outcome).Code_, SIGSEGV);
    }
#endif
 
#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);
    }
}