blob: 9aa0cecb151982b14d5e3551054ad8ec7cec6e03 [file] [log] [blame]
// Copyright 2017 The Chromium 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 "base/test/scoped_task_environment.h"
#include <memory>
#include "base/atomicops.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/metrics/statistics_recorder.h"
#include "base/synchronization/atomic_flag.h"
#include "base/synchronization/waitable_event.h"
#include "base/task/post_task.h"
#include "base/test/test_timeouts.h"
#include "base/threading/platform_thread.h"
#include "base/threading/sequence_local_storage_slot.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/tick_clock.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#if defined(OS_POSIX)
#include <unistd.h>
#include "base/files/file_descriptor_watcher_posix.h"
#include "starboard/types.h"
#endif // defined(OS_POSIX)
namespace base {
namespace test {
namespace {
class ScopedTaskEnvironmentTest
: public testing::TestWithParam<ScopedTaskEnvironment::MainThreadType> {};
void VerifyRunUntilIdleDidNotReturnAndSetFlag(
AtomicFlag* run_until_idle_returned,
AtomicFlag* task_ran) {
EXPECT_FALSE(run_until_idle_returned->IsSet());
task_ran->Set();
}
void RunUntilIdleTest(
ScopedTaskEnvironment::MainThreadType main_thread_type,
ScopedTaskEnvironment::ExecutionMode execution_control_mode) {
AtomicFlag run_until_idle_returned;
ScopedTaskEnvironment scoped_task_environment(main_thread_type,
execution_control_mode);
AtomicFlag first_main_thread_task_ran;
ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
Unretained(&run_until_idle_returned),
Unretained(&first_main_thread_task_ran)));
AtomicFlag first_task_scheduler_task_ran;
PostTask(FROM_HERE, BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
Unretained(&run_until_idle_returned),
Unretained(&first_task_scheduler_task_ran)));
AtomicFlag second_task_scheduler_task_ran;
AtomicFlag second_main_thread_task_ran;
PostTaskAndReply(FROM_HERE,
BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
Unretained(&run_until_idle_returned),
Unretained(&second_task_scheduler_task_ran)),
BindOnce(&VerifyRunUntilIdleDidNotReturnAndSetFlag,
Unretained(&run_until_idle_returned),
Unretained(&second_main_thread_task_ran)));
scoped_task_environment.RunUntilIdle();
run_until_idle_returned.Set();
EXPECT_TRUE(first_main_thread_task_ran.IsSet());
EXPECT_TRUE(first_task_scheduler_task_ran.IsSet());
EXPECT_TRUE(second_task_scheduler_task_ran.IsSet());
EXPECT_TRUE(second_main_thread_task_ran.IsSet());
}
} // namespace
TEST_P(ScopedTaskEnvironmentTest, QueuedRunUntilIdle) {
RunUntilIdleTest(GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
}
TEST_P(ScopedTaskEnvironmentTest, AsyncRunUntilIdle) {
RunUntilIdleTest(GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
}
// Verify that tasks posted to an ExecutionMode::QUEUED ScopedTaskEnvironment do
// not run outside of RunUntilIdle().
TEST_P(ScopedTaskEnvironmentTest, QueuedTasksDoNotRunOutsideOfRunUntilIdle) {
ScopedTaskEnvironment scoped_task_environment(
GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
AtomicFlag run_until_idle_called;
PostTask(FROM_HERE, BindOnce(
[](AtomicFlag* run_until_idle_called) {
EXPECT_TRUE(run_until_idle_called->IsSet());
},
Unretained(&run_until_idle_called)));
PlatformThread::Sleep(TestTimeouts::tiny_timeout());
run_until_idle_called.Set();
scoped_task_environment.RunUntilIdle();
AtomicFlag other_run_until_idle_called;
PostTask(FROM_HERE, BindOnce(
[](AtomicFlag* other_run_until_idle_called) {
EXPECT_TRUE(other_run_until_idle_called->IsSet());
},
Unretained(&other_run_until_idle_called)));
PlatformThread::Sleep(TestTimeouts::tiny_timeout());
other_run_until_idle_called.Set();
scoped_task_environment.RunUntilIdle();
}
// Verify that a task posted to an ExecutionMode::ASYNC ScopedTaskEnvironment
// can run without a call to RunUntilIdle().
TEST_P(ScopedTaskEnvironmentTest, AsyncTasksRunAsTheyArePosted) {
ScopedTaskEnvironment scoped_task_environment(
GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
WaitableEvent::InitialState::NOT_SIGNALED);
PostTask(FROM_HERE,
BindOnce([](WaitableEvent* task_ran) { task_ran->Signal(); },
Unretained(&task_ran)));
task_ran.Wait();
}
// Verify that a task posted to an ExecutionMode::ASYNC ScopedTaskEnvironment
// after a call to RunUntilIdle() can run without another call to
// RunUntilIdle().
TEST_P(ScopedTaskEnvironmentTest,
AsyncTasksRunAsTheyArePostedAfterRunUntilIdle) {
ScopedTaskEnvironment scoped_task_environment(
GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
scoped_task_environment.RunUntilIdle();
WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
WaitableEvent::InitialState::NOT_SIGNALED);
PostTask(FROM_HERE,
BindOnce([](WaitableEvent* task_ran) { task_ran->Signal(); },
Unretained(&task_ran)));
task_ran.Wait();
}
TEST_P(ScopedTaskEnvironmentTest, DelayedTasks) {
// Use a QUEUED execution-mode environment, so that no tasks are actually
// executed until RunUntilIdle()/FastForwardBy() are invoked.
ScopedTaskEnvironment scoped_task_environment(
GetParam(), ScopedTaskEnvironment::ExecutionMode::QUEUED);
subtle::Atomic32 counter = 0;
constexpr base::TimeDelta kShortTaskDelay = TimeDelta::FromDays(1);
// Should run only in MOCK_TIME environment when time is fast-forwarded.
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 4);
},
Unretained(&counter)),
kShortTaskDelay);
// TODO(gab): This currently doesn't run because the TaskScheduler's clock
// isn't mocked but it should be.
PostDelayedTask(FROM_HERE,
Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 128);
},
Unretained(&counter)),
kShortTaskDelay);
constexpr base::TimeDelta kLongTaskDelay = TimeDelta::FromDays(7);
// Same as first task, longer delays to exercise
// FastForwardUntilNoTasksRemain().
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 8);
},
Unretained(&counter)),
TimeDelta::FromDays(5));
ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE,
Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 16);
},
Unretained(&counter)),
kLongTaskDelay);
ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 1);
},
Unretained(&counter)));
PostTask(FROM_HERE, Bind(
[](subtle::Atomic32* counter) {
subtle::NoBarrier_AtomicIncrement(counter, 2);
},
Unretained(&counter)));
// This expectation will fail flakily if the preceding PostTask() is executed
// asynchronously, indicating a problem with the QUEUED execution mode.
int expected_value = 0;
EXPECT_EQ(expected_value, counter);
// RunUntilIdle() should process non-delayed tasks only in all queues.
scoped_task_environment.RunUntilIdle();
expected_value += 1;
expected_value += 2;
EXPECT_EQ(expected_value, counter);
if (GetParam() == ScopedTaskEnvironment::MainThreadType::MOCK_TIME) {
// Delay inferior to the delay of the first posted task.
constexpr base::TimeDelta kInferiorTaskDelay = TimeDelta::FromSeconds(1);
static_assert(kInferiorTaskDelay < kShortTaskDelay,
"|kInferiorTaskDelay| should be "
"set to a value inferior to the first posted task's delay.");
scoped_task_environment.FastForwardBy(kInferiorTaskDelay);
EXPECT_EQ(expected_value, counter);
scoped_task_environment.FastForwardBy(kShortTaskDelay - kInferiorTaskDelay);
expected_value += 4;
EXPECT_EQ(expected_value, counter);
scoped_task_environment.FastForwardUntilNoTasksRemain();
expected_value += 8;
expected_value += 16;
EXPECT_EQ(expected_value, counter);
}
}
// Regression test for https://crbug.com/824770.
TEST_P(ScopedTaskEnvironmentTest, SupportsSequenceLocalStorageOnMainThread) {
ScopedTaskEnvironment scoped_task_environment(
GetParam(), ScopedTaskEnvironment::ExecutionMode::ASYNC);
SequenceLocalStorageSlot<int> sls_slot;
sls_slot.Set(5);
EXPECT_EQ(5, sls_slot.Get());
}
#if defined(OS_POSIX)
TEST_F(ScopedTaskEnvironmentTest, SupportsFileDescriptorWatcherOnIOMainThread) {
ScopedTaskEnvironment scoped_task_environment(
ScopedTaskEnvironment::MainThreadType::IO,
ScopedTaskEnvironment::ExecutionMode::ASYNC);
int pipe_fds_[2];
ASSERT_EQ(0, pipe(pipe_fds_));
RunLoop run_loop;
// The write end of a newly created pipe is immediately writable.
auto controller = FileDescriptorWatcher::WatchWritable(
pipe_fds_[1], run_loop.QuitClosure());
// This will hang if the notification doesn't occur as expected.
run_loop.Run();
}
#endif // defined(OS_POSIX)
// Verify that the TickClock returned by
// |ScopedTaskEnvironment::GetMockTickClock| gets updated when the
// FastForward(By|UntilNoTasksRemain) functions are called.
TEST_F(ScopedTaskEnvironmentTest, FastForwardAdvanceTickClock) {
auto recorder = StatisticsRecorder::CreateTemporaryForTesting();
// Use a QUEUED execution-mode environment, so that no tasks are actually
// executed until RunUntilIdle()/FastForwardBy() are invoked.
ScopedTaskEnvironment scoped_task_environment(
ScopedTaskEnvironment::MainThreadType::MOCK_TIME,
ScopedTaskEnvironment::ExecutionMode::QUEUED);
constexpr base::TimeDelta kShortTaskDelay = TimeDelta::FromDays(1);
ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, base::DoNothing(),
kShortTaskDelay);
constexpr base::TimeDelta kLongTaskDelay = TimeDelta::FromDays(7);
ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE, base::DoNothing(),
kLongTaskDelay);
const base::TickClock* tick_clock =
scoped_task_environment.GetMockTickClock();
base::TimeTicks tick_clock_ref = tick_clock->NowTicks();
// Make sure that |FastForwardBy| advances the clock.
scoped_task_environment.FastForwardBy(kShortTaskDelay);
EXPECT_EQ(kShortTaskDelay, tick_clock->NowTicks() - tick_clock_ref);
// Make sure that |FastForwardUntilNoTasksRemain| advances the clock.
scoped_task_environment.FastForwardUntilNoTasksRemain();
EXPECT_EQ(kLongTaskDelay, tick_clock->NowTicks() - tick_clock_ref);
// Fast-forwarding to a time at which there's no tasks should also advance the
// clock.
scoped_task_environment.FastForwardBy(kLongTaskDelay);
EXPECT_EQ(kLongTaskDelay * 2, tick_clock->NowTicks() - tick_clock_ref);
}
INSTANTIATE_TEST_CASE_P(
MainThreadDefault,
ScopedTaskEnvironmentTest,
::testing::Values(ScopedTaskEnvironment::MainThreadType::DEFAULT));
INSTANTIATE_TEST_CASE_P(
MainThreadMockTime,
ScopedTaskEnvironmentTest,
::testing::Values(ScopedTaskEnvironment::MainThreadType::MOCK_TIME));
#if !defined(STARBOARD)
INSTANTIATE_TEST_CASE_P(
MainThreadUI,
ScopedTaskEnvironmentTest,
::testing::Values(ScopedTaskEnvironment::MainThreadType::UI));
#endif // !defined(STARBOARD)
INSTANTIATE_TEST_CASE_P(
MainThreadIO,
ScopedTaskEnvironmentTest,
::testing::Values(ScopedTaskEnvironment::MainThreadType::IO));
} // namespace test
} // namespace base