1 // Copyright 2014 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 <string>
6
7 #include "base/cancelable_callback.h"
8 #include "base/format_macros.h"
9 #include "base/memory/scoped_ptr.h"
10 #include "base/strings/stringprintf.h"
11 #include "base/test/test_pending_task.h"
12 #include "cc/test/ordered_simple_task_runner.h"
13 #include "testing/gtest/include/gtest/gtest.h"
14
15 // We pass EXPECT_TRUE / EXPECT_FALSE macros rather than a boolean as on some
16 // compilers EXPECT_EQ(false, XXXX) fails to compile as gtest tries to convert
17 // the false value to null causing a -Werror=conversion-null error.
18 #define RUN_AND_CHECK_RESULT( \
19 tasks_remain_expect_macro, run_func, expected_result) \
20 tasks_remain_expect_macro(task_runner_->run_func); \
21 EXPECT_EQ(expected_result, executed_tasks_); \
22 executed_tasks_ = "";
23
24 namespace {
25
ReturnTrue()26 bool ReturnTrue() {
27 return true;
28 }
29
ReturnFalse()30 bool ReturnFalse() {
31 return false;
32 }
33 };
34
35 namespace cc {
36
TEST(TestOrderablePendingTask,Ordering)37 TEST(TestOrderablePendingTask, Ordering) {
38 TestOrderablePendingTask a;
39 TestOrderablePendingTask b;
40 TestOrderablePendingTask c;
41
42 EXPECT_EQ(a, a);
43 EXPECT_EQ(b, b);
44 EXPECT_EQ(c, c);
45 EXPECT_LT(a, b);
46 EXPECT_LT(b, c);
47 EXPECT_LT(a, c);
48
49 TestOrderablePendingTask a2 = a;
50 EXPECT_EQ(a, a2);
51 EXPECT_LT(a2, b);
52 EXPECT_LT(b, c);
53 EXPECT_LT(a2, c);
54 }
55
56 class OrderedSimpleTaskRunnerTest : public testing::Test {
57 public:
OrderedSimpleTaskRunnerTest()58 OrderedSimpleTaskRunnerTest()
59 : now_src_(TestNowSource::Create(base::TimeTicks())) {
60 task_runner_ = new OrderedSimpleTaskRunner(now_src_, true);
61 }
~OrderedSimpleTaskRunnerTest()62 virtual ~OrderedSimpleTaskRunnerTest() {}
63
64 protected:
65 std::string executed_tasks_;
66 scoped_refptr<TestNowSource> now_src_;
67 scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
68
PostTask(int task_num,base::TimeDelta delay)69 void PostTask(int task_num, base::TimeDelta delay) {
70 base::Closure test_task = base::Bind(&OrderedSimpleTaskRunnerTest::Task,
71 base::Unretained(this),
72 task_num);
73 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
74 }
75
PostTaskWhichPostsInstantTask(int task_num,base::TimeDelta delay)76 void PostTaskWhichPostsInstantTask(int task_num, base::TimeDelta delay) {
77 base::Closure test_task =
78 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsInstantTask,
79 base::Unretained(this),
80 task_num);
81 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
82 }
83
PostTaskWhichPostsDelayedTask(int task_num,base::TimeDelta delay1,base::TimeDelta delay2)84 void PostTaskWhichPostsDelayedTask(int task_num,
85 base::TimeDelta delay1,
86 base::TimeDelta delay2) {
87 base::Closure test_task =
88 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsDelayedTask,
89 base::Unretained(this),
90 task_num,
91 delay2);
92 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay1);
93 }
94
PostTaskWhichCallsRun(int task_num,base::TimeDelta delay)95 void PostTaskWhichCallsRun(int task_num, base::TimeDelta delay) {
96 base::Closure test_task =
97 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichCallsRun,
98 base::Unretained(this),
99 task_num);
100 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
101 }
102
PostTaskWhichPostsTaskAgain(int task_num,base::TimeDelta delay)103 void PostTaskWhichPostsTaskAgain(int task_num, base::TimeDelta delay) {
104 base::Closure test_task =
105 base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsAgain,
106 base::Unretained(this),
107 task_num,
108 delay);
109 task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
110 }
111
112 private:
Task(int task_num)113 void Task(int task_num) {
114 if (!executed_tasks_.empty())
115 executed_tasks_ += " ";
116 executed_tasks_ +=
117 base::StringPrintf("%d(%" PRId64 "ms)",
118 task_num,
119 now_src_->Now().ToInternalValue() /
120 base::Time::kMicrosecondsPerMillisecond);
121 }
122
TaskWhichPostsInstantTask(int task_num)123 void TaskWhichPostsInstantTask(int task_num) {
124 Task(task_num);
125 PostTask(-task_num, base::TimeDelta());
126 }
127
TaskWhichPostsDelayedTask(int task_num,base::TimeDelta delay)128 void TaskWhichPostsDelayedTask(int task_num, base::TimeDelta delay) {
129 Task(task_num);
130 PostTask(-task_num, delay);
131 }
132
TaskWhichCallsRun(int task_num)133 void TaskWhichCallsRun(int task_num) {
134 Task(task_num);
135 task_runner_->RunPendingTasks();
136 }
137
TaskWhichPostsAgain(int task_num,base::TimeDelta delay)138 void TaskWhichPostsAgain(int task_num, base::TimeDelta delay) {
139 Task(task_num);
140 PostTaskWhichPostsTaskAgain(task_num, delay);
141 }
142
143 DISALLOW_COPY_AND_ASSIGN(OrderedSimpleTaskRunnerTest);
144 };
145
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTest)146 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTest) {
147 PostTask(1, base::TimeDelta());
148 PostTask(2, base::TimeDelta());
149 PostTask(3, base::TimeDelta());
150
151 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
152 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
153
154 PostTask(4, base::TimeDelta());
155 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(0ms)");
156 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
157 }
158
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingTasks)159 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingTasks) {
160 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
161 PostTaskWhichPostsInstantTask(2, base::TimeDelta());
162 PostTaskWhichPostsInstantTask(3, base::TimeDelta());
163
164 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
165 RUN_AND_CHECK_RESULT(
166 EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -2(0ms) -3(0ms)");
167 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
168 }
169
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingDelayedTasks)170 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingDelayedTasks) {
171 PostTaskWhichPostsDelayedTask(
172 1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
173 PostTaskWhichPostsDelayedTask(
174 2, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
175 PostTaskWhichPostsDelayedTask(
176 3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
177
178 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
179 RUN_AND_CHECK_RESULT(
180 EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -2(1ms) -3(1ms)");
181 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
182 }
183
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingReordingDelayedTasks)184 TEST_F(OrderedSimpleTaskRunnerTest,
185 SimpleOrderingTestPostingReordingDelayedTasks) {
186 PostTaskWhichPostsDelayedTask(1,
187 base::TimeDelta::FromMilliseconds(1),
188 base::TimeDelta::FromMilliseconds(20));
189 PostTaskWhichPostsDelayedTask(2,
190 base::TimeDelta::FromMilliseconds(2),
191 base::TimeDelta::FromMilliseconds(5));
192 PostTaskWhichPostsDelayedTask(3,
193 base::TimeDelta::FromMilliseconds(3),
194 base::TimeDelta::FromMilliseconds(5));
195
196 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(2ms) 3(3ms)");
197 RUN_AND_CHECK_RESULT(
198 EXPECT_FALSE, RunPendingTasks(), "-2(7ms) -3(8ms) -1(21ms)");
199 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
200 }
201
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingReordingDelayedTasksOverlap)202 TEST_F(OrderedSimpleTaskRunnerTest,
203 SimpleOrderingTestPostingReordingDelayedTasksOverlap) {
204 PostTaskWhichPostsDelayedTask(1,
205 base::TimeDelta::FromMilliseconds(1),
206 base::TimeDelta::FromMilliseconds(5));
207 PostTaskWhichPostsDelayedTask(2,
208 base::TimeDelta::FromMilliseconds(5),
209 base::TimeDelta::FromMilliseconds(10));
210 PostTaskWhichPostsDelayedTask(3,
211 base::TimeDelta::FromMilliseconds(10),
212 base::TimeDelta::FromMilliseconds(1));
213
214 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(5ms)");
215 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-1(6ms) 3(10ms)");
216 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-3(11ms) -2(15ms)");
217 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
218 }
219
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingAndRentrantTasks)220 TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingAndRentrantTasks) {
221 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
222 PostTaskWhichCallsRun(2, base::TimeDelta());
223 PostTaskWhichPostsInstantTask(3, base::TimeDelta());
224
225 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
226 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -3(0ms)");
227 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
228 }
229
TEST_F(OrderedSimpleTaskRunnerTest,SimpleOrderingTestPostingDelayedAndRentrantTasks)230 TEST_F(OrderedSimpleTaskRunnerTest,
231 SimpleOrderingTestPostingDelayedAndRentrantTasks) {
232 PostTaskWhichPostsDelayedTask(
233 1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
234 PostTaskWhichCallsRun(2, base::TimeDelta());
235 PostTaskWhichPostsDelayedTask(
236 3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
237
238 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
239 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -3(1ms)");
240 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
241 }
242
TEST_F(OrderedSimpleTaskRunnerTest,OrderingTestWithDelayedTasks)243 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasks) {
244 PostTask(1, base::TimeDelta());
245 PostTask(2, base::TimeDelta::FromMilliseconds(15));
246 PostTask(3, base::TimeDelta());
247 PostTask(4, base::TimeDelta::FromMilliseconds(8));
248
249 RUN_AND_CHECK_RESULT(
250 EXPECT_FALSE, RunPendingTasks(), "1(0ms) 3(0ms) 4(8ms) 2(15ms)");
251 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
252 }
253
TEST_F(OrderedSimpleTaskRunnerTest,OrderingTestWithDelayedPostingTasks)254 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedPostingTasks) {
255 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
256 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(15));
257 PostTaskWhichPostsInstantTask(3, base::TimeDelta());
258 PostTaskWhichPostsInstantTask(4, base::TimeDelta::FromMilliseconds(8));
259
260 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)");
261 RUN_AND_CHECK_RESULT(
262 EXPECT_TRUE, RunPendingTasks(), "-1(0ms) -3(0ms) 4(8ms)");
263 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-4(8ms) 2(15ms)");
264 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-2(15ms)");
265 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
266 }
267
TEST_F(OrderedSimpleTaskRunnerTest,OrderingTestWithDelayedTasksManualNow)268 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasksManualNow) {
269 task_runner_->SetAutoAdvanceNowToPendingTasks(false);
270 PostTask(1, base::TimeDelta());
271 PostTask(2, base::TimeDelta::FromMilliseconds(15));
272 PostTask(3, base::TimeDelta());
273 PostTask(4, base::TimeDelta::FromMilliseconds(8));
274
275 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)");
276 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "");
277 EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
278 base::TimeDelta::FromMilliseconds(8));
279 now_src_->SetNow(base::TimeTicks::FromInternalValue(5000));
280 EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
281 base::TimeDelta::FromMilliseconds(3));
282 now_src_->SetNow(base::TimeTicks::FromInternalValue(25000));
283 EXPECT_EQ(task_runner_->DelayToNextTaskTime(), base::TimeDelta());
284 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(25ms) 2(25ms)");
285 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
286 }
287
TEST_F(OrderedSimpleTaskRunnerTest,RunUntilIdle)288 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdle) {
289 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
290 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "1(0ms) -1(0ms)");
291 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "");
292 }
293
TEST_F(OrderedSimpleTaskRunnerTest,RunUntilTimeAutoNow)294 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeAutoNow) {
295 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
296 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
297 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
298
299 task_runner_->SetAutoAdvanceNowToPendingTasks(true);
300
301 base::TimeTicks run_at = base::TimeTicks();
302
303 run_at += base::TimeDelta::FromMilliseconds(2);
304 RUN_AND_CHECK_RESULT(
305 EXPECT_TRUE, RunUntilTime(run_at), "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
306 EXPECT_EQ(run_at, now_src_->Now());
307
308 run_at += base::TimeDelta::FromMilliseconds(1);
309 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
310 EXPECT_EQ(run_at, now_src_->Now());
311
312 run_at += base::TimeDelta::FromMilliseconds(1);
313 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
314 EXPECT_EQ(run_at, now_src_->Now());
315 }
316
TEST_F(OrderedSimpleTaskRunnerTest,RunUntilTimeManualNow)317 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeManualNow) {
318 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
319 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
320 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
321
322 task_runner_->SetAutoAdvanceNowToPendingTasks(false);
323
324 base::TimeTicks run_at = base::TimeTicks();
325
326 run_at += base::TimeDelta::FromMilliseconds(2);
327 RUN_AND_CHECK_RESULT(
328 EXPECT_TRUE, RunUntilTime(run_at), "1(2ms) 2(2ms) -1(2ms) -2(2ms)");
329 EXPECT_EQ(run_at, now_src_->Now());
330
331 run_at += base::TimeDelta::FromMilliseconds(1);
332 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
333 EXPECT_EQ(run_at, now_src_->Now());
334
335 run_at += base::TimeDelta::FromMilliseconds(1);
336 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
337 EXPECT_EQ(run_at, now_src_->Now());
338 }
339
TEST_F(OrderedSimpleTaskRunnerTest,RunForPeriod)340 TEST_F(OrderedSimpleTaskRunnerTest, RunForPeriod) {
341 PostTaskWhichPostsInstantTask(1, base::TimeDelta());
342 PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
343 PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
344
345 RUN_AND_CHECK_RESULT(EXPECT_TRUE,
346 RunForPeriod(base::TimeDelta::FromMilliseconds(2)),
347 "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
348 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2),
349 now_src_->Now());
350
351 RUN_AND_CHECK_RESULT(EXPECT_FALSE,
352 RunForPeriod(base::TimeDelta::FromMilliseconds(1)),
353 "3(3ms) -3(3ms)");
354 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
355 now_src_->Now());
356
357 RUN_AND_CHECK_RESULT(
358 EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromMilliseconds(1)), "");
359 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4),
360 now_src_->Now());
361 }
362
TEST_F(OrderedSimpleTaskRunnerTest,RunTasksWhileWithCallback)363 TEST_F(OrderedSimpleTaskRunnerTest, RunTasksWhileWithCallback) {
364 base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
365 base::Callback<bool(void)> return_false = base::Bind(&ReturnFalse);
366
367 PostTask(1, base::TimeDelta());
368
369 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunTasksWhile(return_false), "");
370 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "1(0ms)");
371 }
372
TEST_F(OrderedSimpleTaskRunnerTest,EmptyTaskList)373 TEST_F(OrderedSimpleTaskRunnerTest, EmptyTaskList) {
374 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
375 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "");
376
377 ASSERT_EQ(base::TimeTicks(), now_src_->Now());
378
379 RUN_AND_CHECK_RESULT(
380 EXPECT_FALSE, RunUntilTime(base::TimeTicks::FromInternalValue(100)), "");
381 EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->Now());
382
383 RUN_AND_CHECK_RESULT(
384 EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromInternalValue(100)), "");
385 EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->Now());
386
387 base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
388 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "");
389 }
390
TEST_F(OrderedSimpleTaskRunnerTest,RunPendingTasksTimeout)391 TEST_F(OrderedSimpleTaskRunnerTest, RunPendingTasksTimeout) {
392 PostTask(1, base::TimeDelta());
393 PostTask(2, base::TimeDelta());
394 PostTask(3, base::TimeDelta());
395 PostTask(4, base::TimeDelta());
396 PostTask(5, base::TimeDelta());
397 PostTask(6, base::TimeDelta());
398
399 task_runner_->SetRunTaskLimit(3);
400 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
401
402 task_runner_->SetRunTaskLimit(2);
403 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "4(0ms) 5(0ms)");
404
405 task_runner_->SetRunTaskLimit(0);
406 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "");
407 }
408
TEST_F(OrderedSimpleTaskRunnerTest,RunUntilIdleTimeout)409 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdleTimeout) {
410 PostTaskWhichPostsTaskAgain(1, base::TimeDelta::FromMilliseconds(3));
411
412 task_runner_->SetRunTaskLimit(3);
413 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(3ms) 1(6ms) 1(9ms)");
414
415 task_runner_->SetRunTaskLimit(2);
416 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(12ms) 1(15ms)");
417
418 task_runner_->SetRunTaskLimit(0);
419 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "");
420 }
421
TEST_F(OrderedSimpleTaskRunnerTest,RunUntilTimeout)422 TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeout) {
423 base::TimeTicks run_to = base::TimeTicks() + base::TimeDelta::FromSeconds(1);
424
425 PostTask(1, base::TimeDelta::FromMilliseconds(1));
426 PostTask(2, base::TimeDelta::FromMilliseconds(2));
427 PostTask(3, base::TimeDelta::FromMilliseconds(3));
428 PostTask(4, base::TimeDelta::FromMilliseconds(4));
429 PostTask(5, base::TimeDelta::FromMilliseconds(5));
430
431 EXPECT_EQ(base::TimeTicks(), now_src_->Now());
432 task_runner_->SetRunTaskLimit(3);
433 RUN_AND_CHECK_RESULT(
434 EXPECT_TRUE, RunUntilTime(run_to), "1(1ms) 2(2ms) 3(3ms)");
435 EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
436 now_src_->Now());
437
438 task_runner_->SetRunTaskLimit(0);
439 RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilTime(run_to), "");
440
441 task_runner_->SetRunTaskLimit(100);
442 RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_to), "4(4ms) 5(5ms)");
443 EXPECT_EQ(run_to, now_src_->Now());
444 }
445
446 } // namespace cc
447