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
24namespace {
25
26bool ReturnTrue() {
27  return true;
28}
29
30bool ReturnFalse() {
31  return false;
32}
33};
34
35namespace cc {
36
37TEST(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
56class OrderedSimpleTaskRunnerTest : public testing::Test {
57 public:
58  OrderedSimpleTaskRunnerTest()
59      : now_src_(TestNowSource::Create(base::TimeTicks())) {
60    task_runner_ = new OrderedSimpleTaskRunner(now_src_, true);
61  }
62  virtual ~OrderedSimpleTaskRunnerTest() {}
63
64 protected:
65  std::string executed_tasks_;
66  scoped_refptr<TestNowSource> now_src_;
67  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
68
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
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
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
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
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:
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
123  void TaskWhichPostsInstantTask(int task_num) {
124    Task(task_num);
125    PostTask(-task_num, base::TimeDelta());
126  }
127
128  void TaskWhichPostsDelayedTask(int task_num, base::TimeDelta delay) {
129    Task(task_num);
130    PostTask(-task_num, delay);
131  }
132
133  void TaskWhichCallsRun(int task_num) {
134    Task(task_num);
135    task_runner_->RunPendingTasks();
136  }
137
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
146TEST_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
159TEST_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
170TEST_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
184TEST_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
202TEST_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
220TEST_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
230TEST_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
243TEST_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
254TEST_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
268TEST_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
288TEST_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
294TEST_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
317TEST_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
340TEST_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
363TEST_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
373TEST_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
391TEST_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
409TEST_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
422TEST_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