| // Copyright 2023 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include <lib/async-loop/testing/cpp/real_loop.h> | |
| #include <lib/async/cpp/task.h> | |
| #include <lib/async/cpp/time.h> | |
| #include <lib/async/dispatcher.h> | |
| #include <lib/fpromise/bridge.h> | |
| #include <lib/fpromise/promise.h> | |
| #include <lib/sync/cpp/completion.h> | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <lib/zx/time.h> | |
| #include <gtest/gtest.h> | |
| #include "src/lib/testing/predicates/status.h" | |
| namespace { | |
| class RealLoopFixtureTest : public loop_fixture::RealLoop, public testing::Test {}; | |
| TEST_F(RealLoopFixtureTest, Timeout) { | |
| zx::time posted_at = async::Now(dispatcher()); | |
| zx::time called_at = zx::time::infinite_past(); | |
| zx::duration timeout = zx::msec(100); | |
| async::PostDelayedTask( | |
| dispatcher(), [&called_at, dispatcher = dispatcher()] { called_at = async::Now(dispatcher); }, | |
| timeout); | |
| // Run until `called_at` is updated. | |
| RunLoopWithTimeoutOrUntil([&called_at]() { return called_at > zx::time::infinite_past(); }, | |
| zx::sec(1)); | |
| // The task should have been called only after `timeout` has elapsed. | |
| EXPECT_GE(called_at, posted_at + timeout); | |
| } | |
| TEST_F(RealLoopFixtureTest, NoTimeout) { | |
| // Check that the first run loop doesn't hit the timeout. | |
| QuitLoop(); | |
| EXPECT_FALSE(RunLoopWithTimeout(zx::msec(10))); | |
| // But the second does. | |
| EXPECT_TRUE(RunLoopWithTimeout(zx::msec(10))); | |
| } | |
| TEST_F(RealLoopFixtureTest, RunPromiseResolved) { | |
| { | |
| auto res = RunPromise(fpromise::make_ok_promise("hello")); | |
| ASSERT_TRUE(res.is_ok()); | |
| EXPECT_EQ(res.value(), "hello"); | |
| } | |
| { | |
| auto res = RunPromise(fpromise::make_error_promise(1234)); | |
| ASSERT_TRUE(!res.is_ok()); | |
| EXPECT_EQ(res.error(), 1234); | |
| } | |
| } | |
| TEST_F(RealLoopFixtureTest, RunPromiseRequiresMultipleLoops) { | |
| // Make a promise whose closure needs to run 5 times to complete, and which | |
| // wakes itself up after each loop. | |
| fpromise::result<std::string> res = RunPromise(fpromise::make_promise( | |
| [count = 0](fpromise::context& ctx) mutable -> fpromise::result<std::string> { | |
| if (count < 5) { | |
| count++; | |
| // Tell the executor to call us again. | |
| ctx.suspend_task().resume_task(); | |
| return fpromise::pending(); | |
| } | |
| return fpromise::ok("finished"); | |
| })); | |
| ASSERT_TRUE(res.is_ok()); | |
| EXPECT_EQ(res.value(), "finished"); | |
| } | |
| // Returns a promise that completes after |delay|. | |
| fpromise::promise<> DelayedPromise(async_dispatcher_t* dispatcher, zx::duration delay) { | |
| fpromise::bridge<> bridge; | |
| async::PostDelayedTask(dispatcher, bridge.completer.bind(), delay); | |
| return bridge.consumer.promise(); | |
| } | |
| TEST_F(RealLoopFixtureTest, RunPromiseDelayed) { | |
| fpromise::result<> res = RunPromise(DelayedPromise(dispatcher(), zx::msec(100))); | |
| EXPECT_TRUE(res.is_ok()); | |
| } | |
| TEST_F(RealLoopFixtureTest, RunPromiseVoidValue) { | |
| auto res = RunPromise(fpromise::make_ok_promise()); | |
| ASSERT_TRUE(res.is_ok()); | |
| static_assert(std::is_same_v<decltype(res)::value_type, void>); | |
| } | |
| TEST_F(RealLoopFixtureTest, RunPromiseMoveOnlyValue) { | |
| auto res = RunPromise(fpromise::make_ok_promise(std::make_unique<int>(42))); | |
| ASSERT_TRUE(res.is_ok()); | |
| ASSERT_NE(res.value().get(), nullptr); | |
| ASSERT_EQ(*res.value(), 42); | |
| } | |
| TEST_F(RealLoopFixtureTest, PerformBlockingWork) { | |
| // Check that both the async loop and the blocking work are running simultaneously. | |
| auto result = PerformBlockingWork([&] { | |
| libsync::Completion work_done; | |
| EXPECT_OK(async::PostTask(dispatcher(), [&] { work_done.Signal(); })); | |
| work_done.Wait(); | |
| return 42; | |
| }); | |
| static_assert(std::is_same_v<decltype(result), int>); | |
| ASSERT_EQ(result, 42); | |
| } | |
| TEST_F(RealLoopFixtureTest, PerformBlockingWorkVoidValue) { | |
| struct C { | |
| static void ReturnVoid() {} | |
| }; | |
| static_assert(std::is_same_v<decltype(PerformBlockingWork(&C::ReturnVoid)), void>); | |
| PerformBlockingWork(&C::ReturnVoid); | |
| } | |
| TEST_F(RealLoopFixtureTest, PerformBlockingWorkMoveOnlyValue) { | |
| std::unique_ptr res = PerformBlockingWork([] { return std::make_unique<int>(42); }); | |
| ASSERT_NE(res.get(), nullptr); | |
| ASSERT_EQ(*res, 42); | |
| } | |
| } // namespace |