| // Copyright 2018 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-testing/test_loop.h> | |
| #include <lib/async/cpp/task.h> | |
| #include <lib/async/cpp/time.h> | |
| #include <lib/async/cpp/wait.h> | |
| #include <lib/async/default.h> | |
| #include <lib/async/dispatcher.h> | |
| #include <lib/async/task.h> | |
| #include <lib/fit/function.h> | |
| #include <lib/zx/event.h> | |
| #include <lib/zx/time.h> | |
| #include <sys/socket.h> | |
| #include <zircon/assert.h> | |
| #include <zircon/syscalls.h> | |
| #include <zircon/types.h> | |
| #include <array> | |
| #include <memory> | |
| #include <string> | |
| #include <utility> | |
| #include <gtest/gtest.h> | |
| namespace { | |
| // Initializes |wait| to wait on |event| to call |closure| once |trigger| is | |
| // signaled. | |
| void InitWait(async::Wait* wait, fit::closure closure, const zx::event& event, | |
| zx_signals_t trigger) { | |
| wait->set_handler([closure = std::move(closure)](async_dispatcher_t*, async::Wait*, zx_status_t, | |
| const zx_packet_signal_t*) { closure(); }); | |
| wait->set_object(event.get()); | |
| wait->set_trigger(trigger); | |
| } | |
| TEST(TestLoopTest, DefaultDispatcherIsSetAndUnset) { | |
| ASSERT_EQ(async_get_default_dispatcher(), nullptr); | |
| { | |
| async::TestLoop loop; | |
| EXPECT_EQ(loop.dispatcher(), async_get_default_dispatcher()); | |
| } | |
| EXPECT_EQ(async_get_default_dispatcher(), nullptr); | |
| } | |
| TEST(TestLoopTest, RandomSeedFromEnv) { | |
| const char* kTestRandomSeed = "1234"; | |
| char* old_random_seed = getenv("TEST_LOOP_RANDOM_SEED"); | |
| setenv("TEST_LOOP_RANDOM_SEED", kTestRandomSeed, /*overwrite=*/true); | |
| async::TestLoop loop; | |
| EXPECT_EQ(loop.initial_state(), 1234u); | |
| if (old_random_seed) { | |
| setenv("TEST_LOOP_RANDOM_SEED", old_random_seed, /*overwrite=*/true); | |
| } else { | |
| unsetenv("TEST_LOOP_RANDOM_SEED"); | |
| } | |
| } | |
| TEST(TestLoopDispatcher, FakeClockTimeIsCorrect) { | |
| async::TestLoop loop; | |
| EXPECT_EQ(0, loop.Now().get()); | |
| EXPECT_EQ(0, async::Now(loop.dispatcher()).get()); | |
| loop.RunUntilIdle(); | |
| EXPECT_EQ(0, loop.Now().get()); | |
| EXPECT_EQ(0, async::Now(loop.dispatcher()).get()); | |
| loop.RunFor(zx::nsec(1)); | |
| EXPECT_EQ(1, loop.Now().get()); | |
| EXPECT_EQ(1, async::Now(loop.dispatcher()).get()); | |
| loop.RunUntil(zx::time() + zx::nsec(3)); | |
| EXPECT_EQ(3, loop.Now().get()); | |
| EXPECT_EQ(3, async::Now(loop.dispatcher()).get()); | |
| loop.RunFor(zx::nsec(7)); | |
| EXPECT_EQ(10, loop.Now().get()); | |
| EXPECT_EQ(10, async::Now(loop.dispatcher()).get()); | |
| loop.RunUntil(zx::time() + zx::nsec(12)); | |
| EXPECT_EQ(12, loop.Now().get()); | |
| EXPECT_EQ(12, async::Now(loop.dispatcher()).get()); | |
| // t = 12, so nothing should happen in trying to reset the clock to t = 10. | |
| loop.RunUntil(zx::time() + zx::nsec(10)); | |
| EXPECT_EQ(12, loop.Now().get()); | |
| EXPECT_EQ(12, async::Now(loop.dispatcher()).get()); | |
| } | |
| TEST(TestLoopTest, TasksAreDispatched) { | |
| async::TestLoop loop; | |
| bool called = false; | |
| async::PostDelayedTask(loop.dispatcher(), [&called] { called = true; }, zx::sec(2)); | |
| // t = 1: nothing should happen. | |
| loop.RunFor(zx::sec(1)); | |
| EXPECT_FALSE(called); | |
| // t = 2: task should be dispatched. | |
| loop.RunFor(zx::sec(1)); | |
| EXPECT_TRUE(called); | |
| called = false; | |
| async::PostTask(loop.dispatcher(), [&called] { called = true; }); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(called); | |
| } | |
| TEST(TestLoopTest, QuitAndReset) { | |
| async::TestLoop loop; | |
| async::PostDelayedTask(loop.dispatcher(), [] {}, zx::sec(1)); | |
| loop.Quit(); | |
| // Loop has quit, so time does not advance and no work is done. | |
| EXPECT_FALSE(loop.RunFor(zx::sec(1))); | |
| EXPECT_EQ(loop.Now(), zx::time(0)); | |
| // Loop has reset, so time does advance and work is done. | |
| EXPECT_TRUE(loop.RunFor(zx::sec(1))); | |
| EXPECT_EQ(loop.Now(), zx::time(0) + zx::sec(1)); | |
| // Quit task is posted, followed by another task. The quit task is | |
| // dispatched and work is reported. | |
| async::PostTask(loop.dispatcher(), [&loop] { loop.Quit(); }); | |
| async::PostTask(loop.dispatcher(), [] {}); | |
| EXPECT_TRUE(loop.RunUntilIdle()); | |
| // Loop was quit, but it is now reset the remaining task will be dispatched | |
| // on the next run. | |
| EXPECT_TRUE(loop.RunUntilIdle()); | |
| } | |
| TEST(TestLoopTest, RunRepeatedly) { | |
| async::TestLoop loop; | |
| for (int i = 0; i <= 60; ++i) { | |
| async::PostDelayedTask(loop.dispatcher(), [] {}, zx::sec(i)); | |
| } | |
| // Run the loop repeatedly at ten second intervals until the delayed tasks | |
| // are all dispatched. | |
| loop.RunRepeatedlyFor(zx::sec(10)); | |
| EXPECT_GE(loop.Now(), zx::time(0) + zx::min(1)); | |
| // There should be nothing further to dispatch. | |
| EXPECT_FALSE(loop.RunUntilIdle()); | |
| } | |
| TEST(TestLoopTest, SameDeadlinesDispatchInPostingOrder) { | |
| async::TestLoop loop; | |
| bool calledA = false; | |
| bool calledB = false; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| EXPECT_FALSE(calledB); | |
| calledA = true; | |
| }); | |
| async::PostTask(loop.dispatcher(), [&] { | |
| EXPECT_TRUE(calledA); | |
| calledB = true; | |
| }); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_TRUE(calledB); | |
| calledA = false; | |
| calledB = false; | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { | |
| EXPECT_FALSE(calledB); | |
| calledA = true; | |
| }, | |
| zx::sec(5)); | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { | |
| EXPECT_TRUE(calledA); | |
| calledB = true; | |
| }, | |
| zx::sec(5)); | |
| loop.RunFor(zx::sec(5)); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_TRUE(calledB); | |
| } | |
| // Test tasks that post tasks. | |
| TEST(TestLoopTest, NestedTasksAreDispatched) { | |
| async::TestLoop loop; | |
| bool called = false; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { async::PostDelayedTask(loop.dispatcher(), [&] { called = true; }, zx::min(25)); }, | |
| zx::min(35)); | |
| }); | |
| loop.RunFor(zx::hour(1)); | |
| EXPECT_TRUE(called); | |
| } | |
| TEST(TestLoopTest, TimeIsCorrectWhileDispatching) { | |
| async::TestLoop loop; | |
| bool called = false; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| EXPECT_EQ(0, loop.Now().get()); | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { | |
| EXPECT_EQ(10, loop.Now().get()); | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { | |
| EXPECT_EQ(15, loop.Now().get()); | |
| async::PostTask(loop.dispatcher(), [&] { | |
| EXPECT_EQ(15, loop.Now().get()); | |
| called = true; | |
| }); | |
| }, | |
| zx::nsec(5)); | |
| }, | |
| zx::nsec(10)); | |
| }); | |
| loop.RunFor(zx::nsec(15)); | |
| EXPECT_TRUE(called); | |
| } | |
| TEST(TestLoopTest, TasksAreCanceled) { | |
| async::TestLoop loop; | |
| bool calledA = false; | |
| bool calledB = false; | |
| bool calledC = false; | |
| async::TaskClosure taskA([&calledA] { calledA = true; }); | |
| async::TaskClosure taskB([&calledB] { calledB = true; }); | |
| async::TaskClosure taskC([&calledC] { calledC = true; }); | |
| ASSERT_EQ(ZX_OK, taskA.Post(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, taskB.Post(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, taskC.Post(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, taskA.Cancel()); | |
| ASSERT_EQ(ZX_OK, taskC.Cancel()); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| } | |
| TEST(TestLoopTest, TimeIsAdvanced) { | |
| async::TestLoop loop; | |
| bool called = false; | |
| async::TaskClosure task([&called] { called = true; }); | |
| auto time1 = async::Now(loop.dispatcher()); | |
| ASSERT_EQ(ZX_OK, task.PostDelayed(loop.dispatcher(), zx::duration(1))); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(called); | |
| EXPECT_EQ(time1.get(), async::Now(loop.dispatcher()).get()); | |
| loop.AdvanceTimeByEpsilon(); | |
| auto time2 = async::Now(loop.dispatcher()); | |
| EXPECT_FALSE(called); | |
| EXPECT_GT(time2.get(), time1.get()); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(called); | |
| EXPECT_EQ(time2.get(), async::Now(loop.dispatcher()).get()); | |
| } | |
| TEST(TestLoopTest, WaitsAreDispatched) { | |
| async::TestLoop loop; | |
| async::Wait wait; | |
| zx::event event; | |
| bool called = false; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait(&wait, [&called] { called = true; }, event, ZX_USER_SIGNAL_0); | |
| ASSERT_EQ(ZX_OK, wait.Begin(loop.dispatcher())); | |
| // |wait| has not yet been triggered. | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(called); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_1)); | |
| // |wait| will only be triggered by |ZX_USER_SIGNAL_0|. | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(called); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(called); | |
| } | |
| // Test waits that trigger waits. | |
| TEST(TestLoopTest, NestedWaitsAreDispatched) { | |
| async::TestLoop loop; | |
| zx::event event; | |
| async::Wait waitA; | |
| async::Wait waitB; | |
| async::Wait waitC; | |
| bool calledA = false; | |
| bool calledB = false; | |
| bool calledC = false; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait( | |
| &waitA, | |
| [&] { | |
| InitWait( | |
| &waitB, | |
| [&] { | |
| InitWait(&waitC, [&] { calledC = true; }, event, ZX_USER_SIGNAL_2); | |
| waitC.Begin(loop.dispatcher()); | |
| calledB = true; | |
| }, | |
| event, ZX_USER_SIGNAL_1); | |
| waitB.Begin(loop.dispatcher()); | |
| calledA = true; | |
| }, | |
| event, ZX_USER_SIGNAL_0); | |
| ASSERT_EQ(ZX_OK, waitA.Begin(loop.dispatcher())); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(calledA); | |
| EXPECT_FALSE(calledB); | |
| EXPECT_FALSE(calledC); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_FALSE(calledB); | |
| EXPECT_FALSE(calledC); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_1)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_2)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_TRUE(calledC); | |
| } | |
| TEST(TestLoopTest, WaitsAreCanceled) { | |
| async::TestLoop loop; | |
| zx::event event; | |
| async::Wait waitA; | |
| async::Wait waitB; | |
| async::Wait waitC; | |
| bool calledA = false; | |
| bool calledB = false; | |
| bool calledC = false; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait(&waitA, [&calledA] { calledA = true; }, event, ZX_USER_SIGNAL_0); | |
| InitWait(&waitB, [&calledB] { calledB = true; }, event, ZX_USER_SIGNAL_0); | |
| InitWait(&waitC, [&calledC] { calledC = true; }, event, ZX_USER_SIGNAL_0); | |
| ASSERT_EQ(ZX_OK, waitA.Begin(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitB.Begin(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitC.Begin(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitA.Cancel()); | |
| ASSERT_EQ(ZX_OK, waitC.Cancel()); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| } | |
| // Test a task that begins a wait to post a task. | |
| TEST(TestLoopTest, NestedTasksAndWaitsAreDispatched) { | |
| async::TestLoop loop; | |
| zx::event event; | |
| async::Wait wait; | |
| bool wait_begun = false; | |
| bool wait_dispatched = false; | |
| bool inner_task_dispatched = false; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait( | |
| &wait, | |
| [&] { | |
| async::PostDelayedTask( | |
| loop.dispatcher(), [&] { inner_task_dispatched = true; }, zx::min(2)); | |
| wait_dispatched = true; | |
| }, | |
| event, ZX_USER_SIGNAL_0); | |
| async::PostDelayedTask( | |
| loop.dispatcher(), | |
| [&] { | |
| wait.Begin(loop.dispatcher()); | |
| wait_begun = true; | |
| }, | |
| zx::min(3)); | |
| loop.RunFor(zx::min(3)); | |
| EXPECT_TRUE(wait_begun); | |
| EXPECT_FALSE(wait_dispatched); | |
| EXPECT_FALSE(inner_task_dispatched); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(wait_begun); | |
| EXPECT_TRUE(wait_dispatched); | |
| EXPECT_FALSE(inner_task_dispatched); | |
| loop.RunFor(zx::min(2)); | |
| EXPECT_TRUE(wait_begun); | |
| EXPECT_TRUE(wait_dispatched); | |
| EXPECT_TRUE(inner_task_dispatched); | |
| } | |
| TEST(TestLoopTest, DefaultDispatcherIsCurrentLoop) { | |
| async::TestLoop loop; | |
| auto subloop = loop.StartNewLoop(); | |
| bool main_loop_task_run = false; | |
| async_dispatcher_t* main_loop_task_dispatcher = nullptr; | |
| bool sub_loop_task_run = false; | |
| async_dispatcher_t* sub_loop_task_dispatcher = nullptr; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| main_loop_task_run = true; | |
| main_loop_task_dispatcher = async_get_default_dispatcher(); | |
| }); | |
| async::PostTask(subloop->dispatcher(), [&] { | |
| sub_loop_task_run = true; | |
| sub_loop_task_dispatcher = async_get_default_dispatcher(); | |
| }); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(main_loop_task_run); | |
| EXPECT_EQ(main_loop_task_dispatcher, loop.dispatcher()); | |
| EXPECT_TRUE(sub_loop_task_run); | |
| EXPECT_EQ(sub_loop_task_dispatcher, subloop->dispatcher()); | |
| } | |
| TEST(TestLoopTest, HugeAmountOfTaskAreDispatched) { | |
| // This value must be less than or equal to kernel.port.max-observers. | |
| constexpr size_t kPostCount = 50000; | |
| async::TestLoop loop; | |
| zx::event event; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| size_t called_count = 0; | |
| size_t wait_count = 0; | |
| // Creating the array on the heap as its size is greater than the available | |
| // stack. | |
| auto waits_ptr = std::make_unique<std::array<async::Wait, kPostCount>>(); | |
| auto& waits = *waits_ptr; | |
| for (size_t i = 0; i < kPostCount; ++i) { | |
| InitWait(&waits[i], [&] { wait_count++; }, event, ZX_USER_SIGNAL_0); | |
| ASSERT_EQ(ZX_OK, waits[i].Begin(loop.dispatcher())); | |
| } | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| for (size_t i = 0; i < kPostCount; ++i) { | |
| async::PostTask(loop.dispatcher(), [&] { called_count++; }); | |
| } | |
| loop.RunUntilIdle(); | |
| EXPECT_EQ(kPostCount, called_count); | |
| EXPECT_EQ(kPostCount, wait_count); | |
| } | |
| TEST(TestLoopTest, TasksAreDispatchedOnManyLoops) { | |
| async::TestLoop loop; | |
| auto loopA = loop.StartNewLoop(); | |
| auto loopB = loop.StartNewLoop(); | |
| auto loopC = loop.StartNewLoop(); | |
| bool called = false; | |
| bool calledA = false; | |
| bool calledB = false; | |
| bool calledC = false; | |
| async::TaskClosure taskC([&calledC] { calledC = true; }); | |
| async::PostTask(loopB->dispatcher(), [&calledB] { calledB = true; }); | |
| async::PostDelayedTask(loop.dispatcher(), [&called] { called = true; }, zx::sec(1)); | |
| ASSERT_EQ(ZX_OK, taskC.PostDelayed(loopC->dispatcher(), zx::sec(1))); | |
| async::PostDelayedTask(loopA->dispatcher(), [&calledA] { calledA = true; }, zx::sec(2)); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(called); | |
| EXPECT_FALSE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| taskC.Cancel(); | |
| loop.RunFor(zx::sec(1)); | |
| EXPECT_TRUE(called); | |
| EXPECT_FALSE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| loop.RunFor(zx::sec(1)); | |
| EXPECT_TRUE(called); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_TRUE(calledB); | |
| EXPECT_FALSE(calledC); | |
| } | |
| TEST(TestLoopTest, WaitsAreDispatchedOnManyLoops) { | |
| async::TestLoop loop; | |
| auto loopA = loop.StartNewLoop(); | |
| auto loopB = loop.StartNewLoop(); | |
| auto loopC = loop.StartNewLoop(); | |
| async::Wait wait; | |
| async::Wait waitA; | |
| async::Wait waitB; | |
| async::Wait waitC; | |
| bool called = false; | |
| bool calledA = false; | |
| bool calledB = false; | |
| bool calledC = false; | |
| zx::event event; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait(&wait, [&called] { called = true; }, event, ZX_USER_SIGNAL_0); | |
| InitWait(&waitA, [&calledA] { calledA = true; }, event, ZX_USER_SIGNAL_0); | |
| InitWait(&waitB, [&calledB] { calledB = true; }, event, ZX_USER_SIGNAL_0); | |
| InitWait(&waitC, [&calledC] { calledC = true; }, event, ZX_USER_SIGNAL_0); | |
| ASSERT_EQ(ZX_OK, wait.Begin(loop.dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitA.Begin(loopA->dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitB.Begin(loopB->dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitC.Begin(loopC->dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitB.Cancel()); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(called); | |
| EXPECT_TRUE(calledA); | |
| EXPECT_FALSE(calledB); | |
| EXPECT_TRUE(calledC); | |
| } | |
| // Populates |order| with the order in which two tasks and two waits on four | |
| // loops were dispatched, given a |loop|. | |
| void DetermineDispatchOrder(std::unique_ptr<async::TestLoop> loop, int (*order)[4]) { | |
| auto loopA = loop->StartNewLoop(); | |
| auto loopB = loop->StartNewLoop(); | |
| auto loopC = loop->StartNewLoop(); | |
| async::Wait wait; | |
| async::Wait waitB; | |
| zx::event event; | |
| int i = 0; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0u, &event)); | |
| InitWait(&wait, [&] { (*order)[0] = ++i; }, event, ZX_USER_SIGNAL_0); | |
| async::PostTask(loopA->dispatcher(), [&] { (*order)[1] = ++i; }); | |
| InitWait(&waitB, [&] { (*order)[2] = ++i; }, event, ZX_USER_SIGNAL_0); | |
| async::PostTask(loopC->dispatcher(), [&] { (*order)[3] = ++i; }); | |
| ASSERT_EQ(ZX_OK, wait.Begin(loop->dispatcher())); | |
| ASSERT_EQ(ZX_OK, waitB.Begin(loopB->dispatcher())); | |
| ASSERT_EQ(ZX_OK, event.signal(0u, ZX_USER_SIGNAL_0)); | |
| loop->RunUntilIdle(); | |
| EXPECT_EQ(4, i); | |
| EXPECT_NE(0, (*order)[0]); | |
| EXPECT_NE(0, (*order)[1]); | |
| EXPECT_NE(0, (*order)[2]); | |
| EXPECT_NE(0, (*order)[3]); | |
| } | |
| void SeedTestLoopWithEnv(uint32_t random_seed, std::unique_ptr<async::TestLoop>* loop) { | |
| char buf[12]; | |
| snprintf(buf, sizeof(buf), "%u", random_seed); | |
| EXPECT_EQ(0, setenv("TEST_LOOP_RANDOM_SEED", buf, 1)); | |
| *loop = std::make_unique<async::TestLoop>(); | |
| EXPECT_EQ(0, unsetenv("TEST_LOOP_RANDOM_SEED")); | |
| } | |
| void DispatchOrderIsDeterministicFor(uint32_t random_seed) { | |
| int expected_order[4] = {0, 0, 0, 0}; | |
| std::unique_ptr<async::TestLoop> loop; | |
| ASSERT_NO_FATAL_FAILURE(SeedTestLoopWithEnv(random_seed, &loop)); | |
| ASSERT_NO_FATAL_FAILURE(DetermineDispatchOrder(std::move(loop), &expected_order)); | |
| for (int i = 0; i < 5; ++i) { | |
| for (int j = 0; j < 2; j++) { | |
| int actual_order[4] = {0, 0, 0, 0}; | |
| if (j == 0) { | |
| ASSERT_NO_FATAL_FAILURE(SeedTestLoopWithEnv(random_seed, &loop)); | |
| } else { | |
| loop = std::make_unique<async::TestLoop>(random_seed); | |
| } | |
| ASSERT_NO_FATAL_FAILURE(DetermineDispatchOrder(std::move(loop), &actual_order)); | |
| EXPECT_EQ(expected_order[0], actual_order[0]); | |
| EXPECT_EQ(expected_order[1], actual_order[1]); | |
| EXPECT_EQ(expected_order[2], actual_order[2]); | |
| EXPECT_EQ(expected_order[3], actual_order[3]); | |
| } | |
| } | |
| } | |
| TEST(TestLoopTest, DispatchOrderIsDeterministic) { | |
| DispatchOrderIsDeterministicFor(1); | |
| DispatchOrderIsDeterministicFor(43); | |
| DispatchOrderIsDeterministicFor(893); | |
| DispatchOrderIsDeterministicFor(39408); | |
| DispatchOrderIsDeterministicFor(844018); | |
| DispatchOrderIsDeterministicFor(83018299); | |
| DispatchOrderIsDeterministicFor(3213); | |
| DispatchOrderIsDeterministicFor(139133113); | |
| DispatchOrderIsDeterministicFor(1323234373); | |
| } | |
| void BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(uint32_t random_seed) { | |
| std::unique_ptr<async::TestLoop> loop; | |
| ASSERT_NO_FATAL_FAILURE(SeedTestLoopWithEnv(random_seed, &loop)); | |
| auto loopB = loop->StartNewLoop(); | |
| std::vector<int> elements; | |
| async::PostTask(loop->dispatcher(), [&] { | |
| async::PostTask(loopB->dispatcher(), [&] { elements.push_back(0); }); | |
| EXPECT_TRUE(loop->BlockCurrentSubLoopAndRunOthersUntil( | |
| [&] { return elements.size() == 1 && elements[0] == 0; })); | |
| elements.push_back(1); | |
| }); | |
| loop->RunUntilIdle(); | |
| EXPECT_EQ(elements.size(), 2u); | |
| EXPECT_EQ(elements[0], 0); | |
| EXPECT_EQ(elements[1], 1); | |
| } | |
| TEST(TestLoopTest, BlockCurrentSubLoopAndRunOthersUntilOtherLoop) { | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(1); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(43); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(893); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(39408); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(844018); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(83018299); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(3213); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(139133113); | |
| BlockCurrentSubLoopAndRunOthersUntilOtherLoopFor(1323234373); | |
| } | |
| void BlocksFinishWhenOtherLoopQuitFor(uint32_t random_seed) { | |
| std::unique_ptr<async::TestLoop> loop; | |
| ASSERT_NO_FATAL_FAILURE(SeedTestLoopWithEnv(random_seed, &loop)); | |
| auto loopB = loop->StartNewLoop(); | |
| auto loopC = loop->StartNewLoop(); | |
| async::PostTask(loop->dispatcher(), [&] { loop->Quit(); }); | |
| bool loopB_called = false; | |
| async::PostTask(loopB->dispatcher(), [&] { loopB_called = true; }); | |
| bool block_current_subloop = false; | |
| async::PostTask(loopC->dispatcher(), [&] { | |
| block_current_subloop = | |
| loop->BlockCurrentSubLoopAndRunOthersUntil([&] { return loopB_called; }); | |
| }); | |
| auto time = loop->Now(); | |
| loop->RunFor(zx::sec(1)); | |
| // Run until Idle for the case where the Quit() task is scheduled before the | |
| // blocking task. This ensure that all task have been run, but doesn't advance | |
| // the time. | |
| loop->RunUntilIdle(); | |
| EXPECT_TRUE(loopB_called); | |
| EXPECT_TRUE(block_current_subloop); | |
| // Time should not have flown, as a Quit() has been posted. | |
| EXPECT_EQ(time.get(), loop->Now().get()); | |
| } | |
| TEST(TestLoopTest, BlocksFinishWhenOtherLoopQuit) { | |
| BlocksFinishWhenOtherLoopQuitFor(1); | |
| BlocksFinishWhenOtherLoopQuitFor(43); | |
| BlocksFinishWhenOtherLoopQuitFor(893); | |
| BlocksFinishWhenOtherLoopQuitFor(39408); | |
| BlocksFinishWhenOtherLoopQuitFor(844018); | |
| BlocksFinishWhenOtherLoopQuitFor(83018299); | |
| BlocksFinishWhenOtherLoopQuitFor(3213); | |
| BlocksFinishWhenOtherLoopQuitFor(139133113); | |
| BlocksFinishWhenOtherLoopQuitFor(1323234373); | |
| } | |
| void BlocksWhileOtherLoopAdvanceTimeFor(uint32_t random_seed) { | |
| std::unique_ptr<async::TestLoop> loop; | |
| ASSERT_NO_FATAL_FAILURE(SeedTestLoopWithEnv(random_seed, &loop)); | |
| auto loopB = loop->StartNewLoop(); | |
| auto initial_time = loop->Now(); | |
| bool block_current_subloop = false; | |
| async::PostTask(loop->dispatcher(), [&] { loop->AdvanceTimeByEpsilon(); }); | |
| async::PostTask(loopB->dispatcher(), [&] { | |
| block_current_subloop = | |
| loop->BlockCurrentSubLoopAndRunOthersUntil([&] { return loop->Now() > initial_time; }); | |
| }); | |
| loop->RunUntilIdle(); | |
| EXPECT_TRUE(block_current_subloop); | |
| EXPECT_TRUE(loop->Now() > initial_time); | |
| } | |
| TEST(TestLoopTest, BlocksWhileOtherLoopAdvanceTime) { | |
| BlocksWhileOtherLoopAdvanceTimeFor(1); | |
| BlocksWhileOtherLoopAdvanceTimeFor(43); | |
| BlocksWhileOtherLoopAdvanceTimeFor(893); | |
| BlocksWhileOtherLoopAdvanceTimeFor(39408); | |
| BlocksWhileOtherLoopAdvanceTimeFor(844018); | |
| BlocksWhileOtherLoopAdvanceTimeFor(83018299); | |
| BlocksWhileOtherLoopAdvanceTimeFor(3213); | |
| BlocksWhileOtherLoopAdvanceTimeFor(139133113); | |
| BlocksWhileOtherLoopAdvanceTimeFor(1323234373); | |
| } | |
| // Test that non-async-dispatcher loops run fine. | |
| struct ExternalLoop : async_test_subloop_t { | |
| ExternalLoop() { ops = &kOps; } | |
| // The loop keeps a state, that is repeatedly incremented. | |
| // 0: advance to 1 | |
| // 1: wait until |time_ >= kState1Deadline|, advance to 2 | |
| // 2: advance to 3 | |
| // 3: blocked, needs to be manually advanced | |
| // 4: advance to 5 | |
| // 5: done, do not increment | |
| // 6: finalized | |
| int state_ = 0; | |
| // The current time, according to the TestLoop. | |
| zx_time_t time_ = ZX_TIME_INFINITE_PAST; | |
| constexpr static zx_time_t kState1Deadline = 1000; | |
| constexpr static int kStateFinalized = 6; | |
| // Returns the minimum time for the next transition starting from |state|. | |
| // If |ZX_TIME_INFINITE| is returned, the state should not be advanced. | |
| static zx_time_t NextTransitionTime(int state) { | |
| switch (state) { | |
| case 0: | |
| case 2: | |
| case 4: | |
| // Advance immediately. | |
| return ZX_TIME_INFINITE_PAST; | |
| case 1: | |
| return kState1Deadline; | |
| case 3: | |
| case 5: | |
| return ZX_TIME_INFINITE; | |
| default: | |
| ZX_ASSERT(false); | |
| } | |
| } | |
| static void advance_time_to(async_test_subloop_t* self_generic, zx_time_t time) { | |
| ExternalLoop* self = static_cast<ExternalLoop*>(self_generic); | |
| ZX_ASSERT(self->state_ != kStateFinalized); | |
| static_cast<ExternalLoop*>(self)->time_ = time; | |
| } | |
| static uint8_t dispatch_next_due_message(async_test_subloop_t* self_generic) { | |
| ExternalLoop* self = static_cast<ExternalLoop*>(self_generic); | |
| ZX_ASSERT(self->state_ != kStateFinalized); | |
| zx_time_t transition_time = NextTransitionTime(self->state_); | |
| if (transition_time != ZX_TIME_INFINITE && transition_time <= self->time_) { | |
| self->state_++; | |
| return true; | |
| } else { | |
| return false; | |
| } | |
| } | |
| static uint8_t has_pending_work(async_test_subloop_t* self_generic) { | |
| ExternalLoop* self = static_cast<ExternalLoop*>(self_generic); | |
| ZX_ASSERT(self->state_ != kStateFinalized); | |
| zx_time_t transition_time = NextTransitionTime(self->state_); | |
| return (transition_time != ZX_TIME_INFINITE && transition_time <= self->time_); | |
| } | |
| static zx_time_t get_next_task_due_time(async_test_subloop_t* self_generic) { | |
| ExternalLoop* self = static_cast<ExternalLoop*>(self_generic); | |
| ZX_ASSERT(self->state_ != kStateFinalized); | |
| return NextTransitionTime(self->state_); | |
| } | |
| static void finalize(async_test_subloop_t* self_generic) { | |
| ExternalLoop* self = static_cast<ExternalLoop*>(self_generic); | |
| ZX_ASSERT(self->state_ != kStateFinalized); | |
| self->state_ = kStateFinalized; | |
| } | |
| constexpr static async_test_subloop_ops_t kOps = {advance_time_to, dispatch_next_due_message, | |
| has_pending_work, get_next_task_due_time, | |
| finalize}; | |
| }; | |
| TEST(TestLoopTest, ExternalLoopIsRunAndFinalized) { | |
| auto loop = std::make_unique<async::TestLoop>(); | |
| ExternalLoop subloop; | |
| auto token = loop->RegisterLoop(&subloop); | |
| EXPECT_TRUE(loop->RunUntilIdle()); | |
| EXPECT_EQ(1, subloop.state_); | |
| EXPECT_TRUE(loop->RunUntil(zx::time(subloop.kState1Deadline))); | |
| EXPECT_EQ(3, subloop.state_); | |
| EXPECT_LE(subloop.kState1Deadline, subloop.time_); | |
| subloop.state_ = 4; | |
| EXPECT_TRUE(loop->RunUntilIdle()); | |
| EXPECT_EQ(5, subloop.state_); | |
| token.reset(); | |
| EXPECT_EQ(subloop.kStateFinalized, subloop.state_); | |
| } | |
| TEST(TestLoopTest, BlockCurrentSubLoopAndRunOthersUntilTrue) { | |
| async::TestLoop loop; | |
| bool block_current_subloop = false; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| block_current_subloop = loop.BlockCurrentSubLoopAndRunOthersUntil([] { return true; }); | |
| }); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(block_current_subloop); | |
| } | |
| TEST(TestLoopTest, BlockCurrentSubLoopAndRunOthersUntilFalse) { | |
| async::TestLoop loop; | |
| bool block_current_subloop = true; | |
| async::PostTask(loop.dispatcher(), [&] { | |
| block_current_subloop = loop.BlockCurrentSubLoopAndRunOthersUntil([] { return false; }); | |
| }); | |
| loop.RunUntilIdle(); | |
| EXPECT_FALSE(block_current_subloop); | |
| } | |
| struct Task { | |
| async_task_t task; | |
| bool handled = false; | |
| }; | |
| void ReentrantHandler(async_dispatcher_t* dispatcher, async_task_t* task, zx_status_t result) { | |
| // This is reentrant. | |
| auto* typed_task = reinterpret_cast<Task*>(task); | |
| typed_task->handled = true; | |
| async::Now(dispatcher); | |
| } | |
| // This test just verifies that reentrant tasks dont hang and that proper lock releases exists. | |
| TEST(TestLoopTest, TaskHandlerIsReentrant) { | |
| async::TestLoop loop; | |
| auto task_factory = [] { | |
| Task task; | |
| task.task.state = ASYNC_STATE_INIT; | |
| task.task.handler = &ReentrantHandler; | |
| return task; | |
| }; | |
| auto dispatched_task = task_factory(); | |
| // Dispatching it | |
| EXPECT_EQ(ZX_OK, async_post_task(loop.dispatcher(), &dispatched_task.task)); | |
| loop.RunUntilIdle(); | |
| EXPECT_TRUE(dispatched_task.handled); | |
| // Cancelling it. | |
| auto cancelled_task = task_factory(); | |
| EXPECT_EQ(ZX_OK, async_post_task(loop.dispatcher(), &cancelled_task.task)); | |
| EXPECT_EQ(ZX_OK, async_cancel_task(loop.dispatcher(), &cancelled_task.task)); | |
| // On Shutdown | |
| auto shutdown_task = task_factory(); | |
| { | |
| async::TestLoop shutdown_loop; | |
| EXPECT_EQ(ZX_OK, async_post_task(shutdown_loop.dispatcher(), &shutdown_task.task)); | |
| } | |
| EXPECT_TRUE(shutdown_task.handled); | |
| } | |
| void ReentrantWaitHandler(async_dispatcher_t* dispatcher, async_wait_t* wait, zx_status_t status, | |
| const zx_packet_signal_t* signal) { | |
| async::Now(dispatcher); | |
| } | |
| TEST(TestLoopTest, WaitHandlerIsReentrant) { | |
| async::TestLoop loop; | |
| zx::event event; | |
| ASSERT_EQ(ZX_OK, zx::event::create(0, &event)); | |
| auto wait_factory = [&event] { | |
| async_wait_t wait; | |
| wait.state = ASYNC_STATE_INIT; | |
| wait.handler = &ReentrantWaitHandler; | |
| wait.object = event.borrow()->get(); | |
| wait.trigger = ZX_USER_SIGNAL_0; | |
| wait.options = 0; | |
| return wait; | |
| }; | |
| auto dispatched_wait = wait_factory(); | |
| // Dispatching activated wait. | |
| ASSERT_EQ(ZX_OK, async_begin_wait(loop.dispatcher(), &dispatched_wait)); | |
| event.signal(0, ZX_USER_SIGNAL_0); | |
| loop.RunUntilIdle(); | |
| // Cancelling it. | |
| auto cancelled_wait = wait_factory(); | |
| ASSERT_EQ(ZX_OK, async_begin_wait(loop.dispatcher(), &cancelled_wait)); | |
| ASSERT_EQ(ZX_OK, async_cancel_wait(loop.dispatcher(), &cancelled_wait)); | |
| loop.RunUntilIdle(); | |
| // On Shutdown | |
| auto shutdown_wait = wait_factory(); | |
| { | |
| async::TestLoop shutdown_loop; | |
| ASSERT_EQ(ZX_OK, async_begin_wait(shutdown_loop.dispatcher(), &shutdown_wait)); | |
| } | |
| } | |
| } // namespace |