Function TEST_F

async_simple/coro/test/SleepTest.cpp:49–126

};

TEST_F(SleepTest, testSleep) {
    executors::SimpleExecutor e1(5);

    auto sleepTask = [&]() -> Lazy<> {
        auto current = co_await CurrentExecutor();
        EXPECT_EQ(&e1, current);

        auto startTime = std::chrono::system_clock::now();
        co_await coro::sleep(1s);
        auto endTime = std::chrono::system_clock::now();

        current = co_await CurrentExecutor();
        EXPECT_EQ(&e1, current);

        auto duration = endTime - startTime;
        cout << std::chrono::duration_cast<std::chrono::milliseconds>(duration)
                    .count()
             << endl;
    };

    syncAwait(sleepTask().via(&e1));

    auto sleepTask2 = [&]() -> Lazy<> {
        auto current = co_await CurrentExecutor();
        EXPECT_EQ(&e1, current);

        auto startTime = std::chrono::system_clock::now();
        co_await coro::sleep(900ms);
        auto endTime = std::chrono::system_clock::now();

        current = co_await CurrentExecutor();
        EXPECT_EQ(&e1, current);

        auto duration = endTime - startTime;
        cout << std::chrono::duration_cast<std::chrono::milliseconds>(duration)
                    .count()
             << endl;
    };

    syncAwait(sleepTask2().via(&e1));

    auto sleepTask3 = [&]() -> Lazy<> {
        class Executor : public async_simple::Executor {
        public:
            Executor() = default;
            virtual bool schedule(Func) override { return true; }
            virtual void schedule(Func func, Duration dur) override {
                std::thread([this, func = std::move(func), dur]() {
                    id = std::this_thread::get_id();
                    std::this_thread::sleep_for(dur);
                    func();
                }).detach();
            }
            virtual void schedule(Func func, Duration dur, uint64_t,
                                  Slot*) override {
                schedule(std::move(func), dur);
            }