| // Copyright 2018 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "base/timer/wall_clock_timer.h" | |
| #include <memory> | |
| #include <utility> | |
| #include "base/test/mock_callback.h" | |
| #include "base/test/power_monitor_test.h" | |
| #include "base/test/simple_test_clock.h" | |
| #include "base/test/task_environment.h" | |
| #include "testing/gmock/include/gmock/gmock.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| namespace base { | |
| class WallClockTimerTest : public ::testing::Test { | |
| protected: | |
| // Fast-forwards virtual time by |delta|. If |with_power| is true, both | |
| // |clock_| and |task_environment_| time will be fast-forwarded. Otherwise, | |
| // only |clock_| time will be changed to mimic the behavior when machine is | |
| // suspended. | |
| // Power event will be triggered if |with_power| is set to false. | |
| void FastForwardBy(base::TimeDelta delay, bool with_power = true) { | |
| if (!with_power) | |
| fake_power_monitor_source_.Suspend(); | |
| clock_.Advance(delay); | |
| if (with_power) { | |
| task_environment_.FastForwardBy(delay); | |
| } else { | |
| fake_power_monitor_source_.Resume(); | |
| task_environment_.RunUntilIdle(); | |
| } | |
| } | |
| base::test::ScopedPowerMonitorTestSource fake_power_monitor_source_; | |
| base::test::SingleThreadTaskEnvironment task_environment_{ | |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME}; | |
| base::SimpleTestClock clock_; | |
| }; | |
| TEST_F(WallClockTimerTest, PowerResume) { | |
| ::testing::StrictMock<base::MockOnceClosure> callback; | |
| // Set up a WallClockTimer that will fire in one minute. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| const auto start_time = base::Time::Now(); | |
| const auto run_time = start_time + delay; | |
| clock_.SetNow(start_time); | |
| wall_clock_timer.Start(FROM_HERE, run_time, callback.Get()); | |
| EXPECT_EQ(wall_clock_timer.desired_run_time(), start_time + delay); | |
| // Pretend that time jumps forward 30 seconds while the machine is suspended. | |
| constexpr auto past_time = base::Seconds(30); | |
| FastForwardBy(past_time, /*with_power=*/false); | |
| // Ensure that the timer has not yet fired. | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| EXPECT_EQ(wall_clock_timer.desired_run_time(), start_time + delay); | |
| // Expect that the timer fires at the desired run time. | |
| EXPECT_CALL(callback, Run()); | |
| // Both Time::Now() and |task_environment_| MockTickClock::Now() | |
| // go forward by (|delay| - |past_time|): | |
| FastForwardBy(delay - past_time); | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| } | |
| TEST_F(WallClockTimerTest, UseTimerTwiceInRow) { | |
| ::testing::StrictMock<base::MockOnceClosure> first_callback; | |
| ::testing::StrictMock<base::MockOnceClosure> second_callback; | |
| const auto start_time = base::Time::Now(); | |
| clock_.SetNow(start_time); | |
| // Set up a WallClockTimer that will invoke |first_callback| in one minute. | |
| // Once it's done, it will invoke |second_callback| after the other minute. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, first_callback.Get()); | |
| EXPECT_CALL(first_callback, Run()) | |
| .WillOnce(::testing::InvokeWithoutArgs( | |
| [this, &wall_clock_timer, &second_callback, delay]() { | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, | |
| second_callback.Get()); | |
| })); | |
| FastForwardBy(delay); | |
| ::testing::Mock::VerifyAndClearExpectations(&first_callback); | |
| ::testing::Mock::VerifyAndClearExpectations(&second_callback); | |
| // When the |wall_clock_time| is used for the second time, it can still handle | |
| // power suspension properly. | |
| constexpr auto past_time = base::Seconds(30); | |
| FastForwardBy(past_time, /*with_power=*/false); | |
| ::testing::Mock::VerifyAndClearExpectations(&second_callback); | |
| EXPECT_CALL(second_callback, Run()); | |
| FastForwardBy(delay - past_time); | |
| ::testing::Mock::VerifyAndClearExpectations(&second_callback); | |
| } | |
| TEST_F(WallClockTimerTest, Stop) { | |
| ::testing::StrictMock<base::MockOnceClosure> callback; | |
| clock_.SetNow(base::Time::Now()); | |
| // Set up a WallClockTimer. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, callback.Get()); | |
| // After 20 seconds, timer is stopped. | |
| constexpr auto past_time = base::Seconds(20); | |
| FastForwardBy(past_time); | |
| EXPECT_TRUE(wall_clock_timer.IsRunning()); | |
| wall_clock_timer.Stop(); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| // When power is suspends and resumed, timer won't be resumed. | |
| FastForwardBy(past_time, /*with_power=*/false); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| // Timer won't fire when desired run time is reached. | |
| FastForwardBy(delay - past_time * 2); | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| } | |
| TEST_F(WallClockTimerTest, RestartRunningTimer) { | |
| ::testing::StrictMock<base::MockOnceClosure> first_callback; | |
| ::testing::StrictMock<base::MockOnceClosure> second_callback; | |
| constexpr auto delay = base::Minutes(1); | |
| // Set up a WallClockTimer that will invoke |first_callback| in one minute. | |
| clock_.SetNow(base::Time::Now()); | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, first_callback.Get()); | |
| // After 30 seconds, replace the timer with |second_callback| with new one | |
| // minute delay. | |
| constexpr auto past_time = delay / 2; | |
| FastForwardBy(past_time); | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, | |
| second_callback.Get()); | |
| // |first_callback| is due but it won't be called because it's replaced. | |
| FastForwardBy(past_time); | |
| ::testing::Mock::VerifyAndClearExpectations(&first_callback); | |
| ::testing::Mock::VerifyAndClearExpectations(&second_callback); | |
| // Timer invokes the |second_callback|. | |
| EXPECT_CALL(second_callback, Run()); | |
| FastForwardBy(past_time); | |
| ::testing::Mock::VerifyAndClearExpectations(&first_callback); | |
| ::testing::Mock::VerifyAndClearExpectations(&second_callback); | |
| } | |
| TEST_F(WallClockTimerTest, DoubleStop) { | |
| ::testing::StrictMock<base::MockOnceClosure> callback; | |
| clock_.SetNow(base::Time::Now()); | |
| // Set up a WallClockTimer. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| wall_clock_timer.Start(FROM_HERE, clock_.Now() + delay, callback.Get()); | |
| // After 15 seconds, timer is stopped. | |
| constexpr auto past_time = delay / 4; | |
| FastForwardBy(past_time); | |
| EXPECT_TRUE(wall_clock_timer.IsRunning()); | |
| wall_clock_timer.Stop(); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| // And timer is stopped again later. The second stop should be a no-op. | |
| FastForwardBy(past_time); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| wall_clock_timer.Stop(); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| // Timer won't fire after stop. | |
| FastForwardBy(past_time, /*with_power=*/false); | |
| FastForwardBy(delay - past_time * 3); | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| } | |
| // On some platforms, TickClock will never freeze. WallClockTimer are still | |
| // supported on those platforms. | |
| TEST_F(WallClockTimerTest, NonStopTickClock) { | |
| ::testing::StrictMock<base::MockOnceClosure> callback; | |
| // Set up a WallClockTimer that will fire in one minute. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| const auto start_time = base::Time::Now(); | |
| const auto run_time = start_time + delay; | |
| clock_.SetNow(start_time); | |
| wall_clock_timer.Start(FROM_HERE, run_time, callback.Get()); | |
| EXPECT_EQ(wall_clock_timer.desired_run_time(), start_time + delay); | |
| // Pretend that time jumps forward 30 seconds while the machine is suspended. | |
| constexpr auto past_time = base::Seconds(30); | |
| // Fastword with both clocks even the power is suspended. | |
| fake_power_monitor_source_.Suspend(); | |
| clock_.SetNow(clock_.Now() + past_time); | |
| task_environment_.FastForwardBy(past_time); | |
| fake_power_monitor_source_.Resume(); | |
| // Ensure that the timer has not yet fired. | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| EXPECT_EQ(wall_clock_timer.desired_run_time(), start_time + delay); | |
| // Expect that the timer fires at the desired run time. | |
| EXPECT_CALL(callback, Run()); | |
| // Both Time::Now() and |task_environment_| MockTickClock::Now() | |
| // go forward by (|delay| - |past_time|): | |
| FastForwardBy(delay - past_time); | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| } | |
| TEST_F(WallClockTimerTest, NonStopTickClockWithLongPause) { | |
| ::testing::StrictMock<base::MockOnceClosure> callback; | |
| // Set up a WallClockTimer that will fire in one minute. | |
| WallClockTimer wall_clock_timer(&clock_, | |
| task_environment_.GetMockTickClock()); | |
| constexpr auto delay = base::Minutes(1); | |
| const auto start_time = base::Time::Now(); | |
| const auto run_time = start_time + delay; | |
| clock_.SetNow(start_time); | |
| wall_clock_timer.Start(FROM_HERE, run_time, callback.Get()); | |
| EXPECT_EQ(wall_clock_timer.desired_run_time(), start_time + delay); | |
| // Pretend that time jumps forward 60 seconds while the machine is suspended. | |
| constexpr auto past_time = base::Seconds(60); | |
| // Fastword with both clocks even the power is suspended. Timer fires at the | |
| // moment of power resume. | |
| EXPECT_CALL(callback, Run()); | |
| fake_power_monitor_source_.Suspend(); | |
| clock_.SetNow(clock_.Now() + past_time); | |
| task_environment_.FastForwardBy(past_time); | |
| fake_power_monitor_source_.Resume(); | |
| ::testing::Mock::VerifyAndClearExpectations(&callback); | |
| EXPECT_FALSE(wall_clock_timer.IsRunning()); | |
| } | |
| } // namespace base |