OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/task_scheduler/delayed_task_manager.h" | |
6 | |
7 #include <memory> | |
8 #include <utility> | |
9 | |
10 #include "base/bind.h" | |
11 #include "base/bind_helpers.h" | |
12 #include "base/memory/ref_counted.h" | |
13 #include "base/task_scheduler/priority_queue.h" | |
14 #include "base/task_scheduler/scheduler_lock.h" | |
15 #include "base/task_scheduler/sequence.h" | |
16 #include "base/task_scheduler/task.h" | |
17 #include "base/time/time.h" | |
18 #include "testing/gmock/include/gmock/gmock.h" | |
19 #include "testing/gtest/include/gtest/gtest.h" | |
20 | |
21 namespace base { | |
22 namespace internal { | |
23 namespace { | |
24 | |
25 class TestDelayedTaskManager : public DelayedTaskManager { | |
26 public: | |
27 TestDelayedTaskManager() | |
28 : DelayedTaskManager( | |
29 Bind(&TestDelayedTaskManager::OnNextDelayedRunTimeUpdated, | |
30 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.
| |
31 | |
32 void SetCurrentTime(TimeTicks now) { now_ = now; } | |
33 | |
34 // DelayedTaskManager: | |
35 TimeTicks Now() const override { return now_; } | |
36 | |
37 MOCK_METHOD0(OnNextDelayedRunTimeUpdated, void()); | |
38 | |
39 private: | |
40 TimeTicks now_; | |
41 | |
42 DISALLOW_COPY_AND_ASSIGN(TestDelayedTaskManager); | |
43 }; | |
44 | |
45 // Verify that GetNextDelayedRunTime() returns a null TimeTicks when there are | |
46 // no pending delayed tasks. | |
47 TEST(TaskSchedulerDelayedTaskManagerTest, | |
48 GetNextDelayedRunTimeNoPendingDelayedTasks) { | |
49 TestDelayedTaskManager manager; | |
50 EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); | |
51 } | |
52 | |
53 // Verify that a delayed task isn't posted before it is ripe for execution. | |
54 TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskBeforeDelayedRunTime) { | |
gab
2016/04/11 18:28:30
s/PostTask.../PostReadyTasks.../ here and below?
fdoray
2016/04/11 19:57:06
Done.
| |
55 testing::StrictMock<TestDelayedTaskManager> manager; | |
56 | |
57 std::unique_ptr<Task> task( | |
58 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
59 task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); | |
60 const Task* task_raw = task.get(); | |
61 scoped_refptr<Sequence> sequence(new Sequence); | |
62 PriorityQueue priority_queue(Bind(&DoNothing)); | |
63 | |
64 // Add |task| to the DelayedTaskManager. | |
65 EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); | |
66 manager.AddDelayedTask(std::move(task), sequence, &priority_queue); | |
67 testing::Mock::VerifyAndClear(&manager); | |
68 EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
69 | |
70 // Ask the DelayedTaskManager to post tasks that are ripe for execution. | |
71 manager.PostReadyTasks(); | |
72 | |
73 // The next delayed run time shouldn't have changed. | |
74 EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
75 | |
76 // |sequence| and |priority_queue| should be empty. | |
77 EXPECT_EQ(nullptr, sequence->PeekTask()); | |
78 EXPECT_TRUE(priority_queue.BeginTransaction()->Peek().is_null()); | |
79 } | |
80 | |
81 // Verify that a delayed task is posted when PostReadyTasks() is called with the | |
82 // current time equal to the task's delayed run time. | |
83 TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskAtDelayedRunTime) { | |
84 testing::StrictMock<TestDelayedTaskManager> manager; | |
85 | |
86 std::unique_ptr<Task> task( | |
87 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
88 task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); | |
89 const Task* task_raw = task.get(); | |
90 scoped_refptr<Sequence> sequence(new Sequence); | |
91 PriorityQueue priority_queue(Bind(&DoNothing)); | |
92 | |
93 // Add |task| to the DelayedTaskManager. | |
94 EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); | |
95 manager.AddDelayedTask(std::move(task), sequence, &priority_queue); | |
96 testing::Mock::VerifyAndClear(&manager); | |
97 EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
98 | |
99 // Fast-forward time to |task_raw|'s delayed run time. | |
100 manager.SetCurrentTime(task_raw->delayed_run_time); | |
101 | |
102 // Ask the DelayedTaskManager to post tasks that are ripe for execution. | |
103 manager.PostReadyTasks(); | |
104 EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); | |
105 | |
106 // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|. | |
107 EXPECT_EQ(task_raw, sequence->PeekTask()); | |
108 EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); | |
109 } | |
110 | |
111 // Verify that a delayed task is posted when PostReadyTasks() is called with the | |
112 // current time greater than the task's delayed run time. | |
113 TEST(TaskSchedulerDelayedTaskManagerTest, PostTaskAfterDelayedRunTime) { | |
114 testing::StrictMock<TestDelayedTaskManager> manager; | |
115 | |
116 std::unique_ptr<Task> task( | |
117 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
118 task->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); | |
119 const Task* task_raw = task.get(); | |
120 scoped_refptr<Sequence> sequence(new Sequence); | |
121 PriorityQueue priority_queue(Bind(&DoNothing)); | |
122 | |
123 // Add |task| to the DelayedTaskManager. | |
124 EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); | |
125 manager.AddDelayedTask(std::move(task), sequence, &priority_queue); | |
126 testing::Mock::VerifyAndClear(&manager); | |
127 EXPECT_EQ(task_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
128 | |
129 // Fast-forward time after |task_raw|'s delayed run time. | |
130 manager.SetCurrentTime(task_raw->delayed_run_time + | |
131 TimeDelta::FromSeconds(10)); | |
132 | |
133 // Ask the DelayedTaskManager to post tasks that are ripe for execution. | |
134 manager.PostReadyTasks(); | |
135 EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); | |
136 | |
137 // Expect to find |task_raw| in |sequence| and |sequence| in |priority_queue|. | |
138 EXPECT_EQ(task_raw, sequence->PeekTask()); | |
139 EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); | |
140 } | |
141 | |
142 // Verify that when multiple tasks are added to a DelayedTaskManager, they are | |
143 // posted when they become ripe for execution. | |
144 TEST(TaskSchedulerDelayedTaskManagerTest, AddAndPostTasks) { | |
145 testing::StrictMock<TestDelayedTaskManager> manager; | |
146 | |
147 scoped_refptr<Sequence> sequence(new Sequence); | |
148 PriorityQueue priority_queue(Bind(&DoNothing)); | |
149 | |
150 std::unique_ptr<Task> task_a( | |
151 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
152 task_a->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(2); | |
153 const Task* task_a_raw = task_a.get(); | |
154 | |
155 std::unique_ptr<Task> task_b( | |
156 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
157 task_b->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(2); | |
158 const Task* task_b_raw = task_b.get(); | |
159 | |
160 std::unique_ptr<Task> task_c( | |
161 new Task(FROM_HERE, Bind(&DoNothing), TaskTraits())); | |
162 task_c->delayed_run_time = manager.Now() + TimeDelta::FromSeconds(1); | |
163 const Task* task_c_raw = task_c.get(); | |
164 | |
165 // Add |task_a| to the DelayedTaskManager. The next delayed run time should be | |
166 // updated to |task_a|'s delayed run time. | |
167 EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); | |
168 manager.AddDelayedTask(std::move(task_a), sequence, &priority_queue); | |
169 testing::Mock::VerifyAndClear(&manager); | |
170 EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
171 | |
172 // Add |task_b| to the DelayedTaskManager. The next delayed run time shouldn't | |
173 // change. | |
174 manager.AddDelayedTask(std::move(task_b), sequence, &priority_queue); | |
175 testing::Mock::VerifyAndClear(&manager); | |
176 EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
177 | |
178 // Add |task_c| to the DelayedTaskManager. The next delayed run time should be | |
179 // updated to |task_c|'s delayed run time. | |
180 EXPECT_CALL(manager, OnNextDelayedRunTimeUpdated()); | |
181 manager.AddDelayedTask(std::move(task_c), sequence, &priority_queue); | |
182 testing::Mock::VerifyAndClear(&manager); | |
183 EXPECT_EQ(task_c_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
184 | |
185 // Fast-forward time to |task_c_raw|'s delayed run time. | |
186 manager.SetCurrentTime(task_c_raw->delayed_run_time); | |
187 | |
188 // Ask the DelayedTaskManager to post tasks that are ripe for execution. | |
189 // |sequence| should be added to |priority_queue|, |task_c_raw| should be | |
190 // added to |sequence| and the next delayed run time should become | |
191 // |task_a_raw|'s delayed run time. | |
192 manager.PostReadyTasks(); | |
193 EXPECT_EQ(sequence, priority_queue.BeginTransaction()->Peek().sequence); | |
194 priority_queue.BeginTransaction()->Pop(); | |
gab
2016/04/11 18:28:30
EXPECT empty PQ
fdoray
2016/04/11 19:57:06
Done.
| |
195 EXPECT_EQ(task_c_raw, sequence->PeekTask()); | |
196 sequence->PopTask(); | |
gab
2016/04/11 18:28:30
EXPECT empty sequence
fdoray
2016/04/11 19:57:06
Done.
| |
197 EXPECT_EQ(task_a_raw->delayed_run_time, manager.GetNextDelayedRunTime()); | |
198 | |
199 // Fast-forward time to |task_a_raw|'s delayed run time. | |
200 manager.SetCurrentTime(task_a_raw->delayed_run_time); | |
201 | |
202 // Ask the DelayedTaskManager to post tasks that are ripe for execution. | |
203 // |sequence| should be added to |priority_queue|, |task_a_raw| and | |
204 // |task_b_raw| should be added to |sequence| and the next delayed run time | |
205 // should become a null TimeTicks. | |
206 manager.PostReadyTasks(); | |
207 EXPECT_EQ(task_a_raw, sequence->PeekTask()); | |
208 sequence->PopTask(); | |
209 EXPECT_EQ(task_b_raw, sequence->PeekTask()); | |
210 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.
| |
211 EXPECT_EQ(TimeTicks(), manager.GetNextDelayedRunTime()); | |
212 } | |
213 | |
214 } // namespace | |
215 } // namespace internal | |
216 } // namespace base | |
OLD | NEW |