Index: base/task_scheduler/delayed_task_manager_unittest.cc |
diff --git a/base/task_scheduler/delayed_task_manager_unittest.cc b/base/task_scheduler/delayed_task_manager_unittest.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..c8c27b76670519e6c60eaa9c51b6d9cbb8b509c2 |
--- /dev/null |
+++ b/base/task_scheduler/delayed_task_manager_unittest.cc |
@@ -0,0 +1,216 @@ |
+// Copyright 2016 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/task_scheduler/delayed_task_manager.h" |
+ |
+#include <memory> |
+#include <utility> |
+ |
+#include "base/bind.h" |
+#include "base/bind_helpers.h" |
+#include "base/memory/ref_counted.h" |
+#include "base/task_scheduler/priority_queue.h" |
+#include "base/task_scheduler/scheduler_lock.h" |
+#include "base/task_scheduler/sequence.h" |
+#include "base/task_scheduler/task.h" |
+#include "base/time/time.h" |
+#include "testing/gmock/include/gmock/gmock.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace base { |
+namespace internal { |
+namespace { |
+ |
+class TestDelayedTaskManager : public DelayedTaskManager { |
+ public: |
+ TestDelayedTaskManager() |
+ : DelayedTaskManager( |
+ Bind(&TestDelayedTaskManager::OnNextDelayedRunTimeUpdated, |
+ Unretained(this))) {} |
gab
2016/04/11 18:28:30
Initialize |now_| to TimeTicks::Now() or we're sti
fdoray
2016/04/11 19:57:06
Done.
|
+ |
+ void SetCurrentTime(TimeTicks now) { now_ = now; } |
+ |
+ // DelayedTaskManager: |
+ TimeTicks Now() const override { return now_; } |
+ |
+ MOCK_METHOD0(OnNextDelayedRunTimeUpdated, void()); |
+ |
+ private: |
+ TimeTicks now_; |
+ |
+ DISALLOW_COPY_AND_ASSIGN(TestDelayedTaskManager); |
+}; |
+ |
+// Verify that GetNextDelayedRunTime() returns a null TimeTicks when there are |
+// no pending delayed tasks. |
+TEST(TaskSchedulerDelayedTaskManagerTest, |
+ GetNextDelayedRunTimeNoPendingDelayedTasks) { |
+ TestDelayedTaskManager manager; |
+ EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); |
+} |
+ |
+// Verify that a delayed task isn't posted before it is ripe for execution. |
+TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskBeforeDelayedRunTime) { |
gab
2016/04/11 18:28:30
s/PostTask.../PostReadyTasks.../ here and below?
fdoray
2016/04/11 19:57:06
Done.
|
+ testing::StrictMock<TestDelayedTaskManager> manager; |
+ |
+ std::unique_ptr<Task> task( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); |
+ const Task* task_raw = task.get(); |
+ scoped_refptr<Sequence> sequence(new Sequence); |
+ PriorityQueue priority_queue(Bind(&DoNothing)); |
+ |
+ // Add |task| to the DelayedTaskManager. |
+ EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); |
+ manager.AddDelayedTask(std::move(task), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Ask the DelayedTaskManager to post tasks that are ripe for execution. |
+ manager.PostReadyTasks(); |
+ |
+ // The next delayed run time shouldn't have changed. |
+ EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // |sequence| and |priority_queue| should be empty. |
+ EXPECT_EQ(nullptr, sequence->PeekTask()); |
+ EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null()); |
+} |
+ |
+// Verify that a delayed task is posted when PostReadyTasks() is called with the |
+// current time equal to the task's delayed run time. |
+TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskAtDelayedRunTime) { |
+ testing::StrictMock<TestDelayedTaskManager> manager; |
+ |
+ std::unique_ptr<Task> task( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); |
+ const Task* task_raw = task.get(); |
+ scoped_refptr<Sequence> sequence(new Sequence); |
+ PriorityQueue priority_queue(Bind(&DoNothing)); |
+ |
+ // Add |task| to the DelayedTaskManager. |
+ EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); |
+ manager.AddDelayedTask(std::move(task), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Fast-forward time to |task_raw|'s delayed run time. |
+ manager.SetCurrentTime(task_raw->delayed_run_time); |
+ |
+ // Ask the DelayedTaskManager to post tasks that are ripe for execution. |
+ manager.PostReadyTasks(); |
+ EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); |
+ |
+ // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|. |
+ EXPECT_EQ(task_raw, sequence->PeekTask()); |
+ EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); |
+} |
+ |
+// Verify that a delayed task is posted when PostReadyTasks() is called with the |
+// current time greater than the task's delayed run time. |
+TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskAfterDelayedRunTime) { |
+ testing::StrictMock<TestDelayedTaskManager> manager; |
+ |
+ std::unique_ptr<Task> task( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); |
+ const Task* task_raw = task.get(); |
+ scoped_refptr<Sequence> sequence(new Sequence); |
+ PriorityQueue priority_queue(Bind(&DoNothing)); |
+ |
+ // Add |task| to the DelayedTaskManager. |
+ EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); |
+ manager.AddDelayedTask(std::move(task), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Fast-forward time after |task_raw|'s delayed run time. |
+ manager.SetCurrentTime(task_raw->delayed_run_time + |
+ TimeDelta::FromSeconds(10)); |
+ |
+ // Ask the DelayedTaskManager to post tasks that are ripe for execution. |
+ manager.PostReadyTasks(); |
+ EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); |
+ |
+ // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|. |
+ EXPECT_EQ(task_raw, sequence->PeekTask()); |
+ EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); |
+} |
+ |
+// Verify that when multiple tasks are added to a DelayedTaskManager, they are |
+// posted when they become ripe for execution. |
+TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostTasks) { |
+ testing::StrictMock<TestDelayedTaskManager> manager; |
+ |
+ scoped_refptr<Sequence> sequence(new Sequence); |
+ PriorityQueue priority_queue(Bind(&DoNothing)); |
+ |
+ std::unique_ptr<Task> task_a( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task_a->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(2); |
+ const Task* task_a_raw = task_a.get(); |
+ |
+ std::unique_ptr<Task> task_b( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task_b->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(2); |
+ const Task* task_b_raw = task_b.get(); |
+ |
+ std::unique_ptr<Task> task_c( |
+ new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); |
+ task_c->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); |
+ const Task* task_c_raw = task_c.get(); |
+ |
+ // Add |task_a| to the DelayedTaskManager. The next delayed run time should be |
+ // updated to |task_a|'s delayed run time. |
+ EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); |
+ manager.AddDelayedTask(std::move(task_a), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Add |task_b| to the DelayedTaskManager. The next delayed run time shouldn't |
+ // change. |
+ manager.AddDelayedTask(std::move(task_b), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Add |task_c| to the DelayedTaskManager. The next delayed run time should be |
+ // updated to |task_c|'s delayed run time. |
+ EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); |
+ manager.AddDelayedTask(std::move(task_c), sequence, &priority_queue); |
+ testing::Mock::VerifyAndClear(&manager); |
+ EXPECT_EQ(task_c_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Fast-forward time to |task_c_raw|'s delayed run time. |
+ manager.SetCurrentTime(task_c_raw->delayed_run_time); |
+ |
+ // Ask the DelayedTaskManager to post tasks that are ripe for execution. |
+ // |sequence| should be added to |priority_queue|, |task_c_raw| should be |
+ // added to |sequence| and the next delayed run time should become |
+ // |task_a_raw|'s delayed run time. |
+ manager.PostReadyTasks(); |
+ EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); |
+ priority_queue.BeginTransaction()->Pop(); |
gab
2016/04/11 18:28:30
EXPECT empty PQ
fdoray
2016/04/11 19:57:06
Done.
|
+ EXPECT_EQ(task_c_raw, sequence->PeekTask()); |
+ sequence->PopTask(); |
gab
2016/04/11 18:28:30
EXPECT empty sequence
fdoray
2016/04/11 19:57:06
Done.
|
+ EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); |
+ |
+ // Fast-forward time to |task_a_raw|'s delayed run time. |
+ manager.SetCurrentTime(task_a_raw->delayed_run_time); |
+ |
+ // Ask the DelayedTaskManager to post tasks that are ripe for execution. |
+ // |sequence| should be added to |priority_queue|, |task_a_raw| and |
+ // |task_b_raw| should be added to |sequence| and the next delayed run time |
+ // should become a null TimeTicks. |
+ manager.PostReadyTasks(); |
+ EXPECT_EQ(task_a_raw, sequence->PeekTask()); |
+ sequence->PopTask(); |
+ EXPECT_EQ(task_b_raw, sequence->PeekTask()); |
+ sequence->PopTask(); |
gab
2016/04/11 18:28:30
Verify PQ as well and empty post pops
fdoray
2016/04/11 19:57:06
Done.
|
+ EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); |
+} |
+ |
+} // namespace |
+} // namespace internal |
+} // namespace base |