Fixing and enhancing OrderedSimpleTaskRunner to allow 100% deterministic tests.

cc/test/ordered_simple_task_runner_unittest.cc

 // Copyright 2014 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 <string>
 
 #include "base/cancelable_callback.h"
+#include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_pending_task.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#define RUN_AND_CHECK_RESULT(tasks_remain, run_func, expected_result) \
+  EXPECT_EQ(tasks_remain, task_runner_->run_func);                    \
+  EXPECT_EQ(expected_result, executed_tasks_);                        \
+  executed_tasks_ = "";
+
+namespace {
+
+bool ReturnTrue() {
+  return true;
+}
+
+bool ReturnFalse() {
+  return false;
+}
+};
+
 namespace cc {
 
+TEST(TestOrderablePendingTask, Ordering) {
+  TestOrderablePendingTask a;
+  TestOrderablePendingTask b;
+  TestOrderablePendingTask c;
+
+  EXPECT_EQ(a, a);
+  EXPECT_EQ(b, b);
+  EXPECT_EQ(c, c);
+  EXPECT_LT(a, b);
+  EXPECT_LT(b, c);
+  EXPECT_LT(a, c);
+
+  TestOrderablePendingTask a2 = a;
+  EXPECT_EQ(a, a2);
+  EXPECT_LT(a2, b);
+  EXPECT_LT(b, c);
+  EXPECT_LT(a2, c);
+}
+
 class OrderedSimpleTaskRunnerTest : public testing::Test {
  public:
-  OrderedSimpleTaskRunnerTest() {
-    task_runner_ = new OrderedSimpleTaskRunner;
+  OrderedSimpleTaskRunnerTest()
+      : now_src_(TestNowSource::Create(base::TimeTicks())) {
+    task_runner_ = new OrderedSimpleTaskRunner(now_src_, true);
   }
   virtual ~OrderedSimpleTaskRunnerTest() {}
 
  protected:
-  void CreateAndPostTask(int task_num, base::TimeDelta delay) {
+  std::string executed_tasks_;
+  scoped_refptr<TestNowSource> now_src_;
+  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
+
+  void PostTask(int task_num, base::TimeDelta delay) {
     base::Closure test_task = base::Bind(&OrderedSimpleTaskRunnerTest::Task,
                                          base::Unretained(this),
                                          task_num);
     task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
   }
 
-  void RunAndCheckResult(const std::string expected_result) {
-    task_runner_->RunPendingTasks();
-    EXPECT_EQ(expected_result, executed_tasks_);
+  void PostTaskWhichPostsInstantTask(int task_num, base::TimeDelta delay) {
+    base::Closure test_task =
+        base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsInstantTask,
+                   base::Unretained(this),
+                   task_num);
+    task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
+  }
+
+  void PostTaskWhichPostsDelayedTask(int task_num,
+                                     base::TimeDelta delay1,
+                                     base::TimeDelta delay2) {
+    base::Closure test_task =
+        base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsDelayedTask,
+                   base::Unretained(this),
+                   task_num,
+                   delay2);
+    task_runner_->PostDelayedTask(FROM_HERE, test_task, delay1);
+  }
+
+  void PostTaskWhichCallsRun(int task_num, base::TimeDelta delay) {
+    base::Closure test_task =
+        base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichCallsRun,
+                   base::Unretained(this),
+                   task_num);
+    task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
+  }
+
+  void PostTaskWhichPostsTaskAgain(int task_num, base::TimeDelta delay) {
+    base::Closure test_task =
+        base::Bind(&OrderedSimpleTaskRunnerTest::TaskWhichPostsAgain,
+                   base::Unretained(this),
+                   task_num,
+                   delay);
+    task_runner_->PostDelayedTask(FROM_HERE, test_task, delay);
   }
 
  private:
-  std::string executed_tasks_;
-  scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
-
   void Task(int task_num) {
     if (!executed_tasks_.empty())
       executed_tasks_ += " ";
-    executed_tasks_ += base::StringPrintf("%d", task_num);
+    executed_tasks_ +=
+        base::StringPrintf("%d(%" PRId64 "ms)",
+                           task_num,
+                           now_src_->Now().ToInternalValue() /
+                               base::Time::kMicrosecondsPerMillisecond);
+  }
+
+  void TaskWhichPostsInstantTask(int task_num) {
+    Task(task_num);
+    PostTask(-task_num, base::TimeDelta());
+  }
+
+  void TaskWhichPostsDelayedTask(int task_num, base::TimeDelta delay) {
+    Task(task_num);
+    PostTask(-task_num, delay);
+  }
+
+  void TaskWhichCallsRun(int task_num) {
+    Task(task_num);
+    task_runner_->RunPendingTasks();
+  }
+
+  void TaskWhichPostsAgain(int task_num, base::TimeDelta delay) {
+    Task(task_num);
+    PostTaskWhichPostsTaskAgain(task_num, delay);
   }
 
   DISALLOW_COPY_AND_ASSIGN(OrderedSimpleTaskRunnerTest);
 };
 
-TEST_F(OrderedSimpleTaskRunnerTest, BasicOrderingTest) {
-  CreateAndPostTask(1, base::TimeDelta());
-  CreateAndPostTask(2, base::TimeDelta());
-  CreateAndPostTask(3, base::TimeDelta());
-
-  RunAndCheckResult("1 2 3");
+TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTest) {
+  PostTask(1, base::TimeDelta());
+  PostTask(2, base::TimeDelta());
+  PostTask(3, base::TimeDelta());
+
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+
+  PostTask(4, base::TimeDelta());
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "4(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingTasks) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(2, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta());
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-1(0ms) -2(0ms) -3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingDelayedTasks) {
+  PostTaskWhichPostsDelayedTask(
+      1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
+  PostTaskWhichPostsDelayedTask(
+      2, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
+  PostTaskWhichPostsDelayedTask(
+      3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-1(1ms) -2(1ms) -3(1ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest,
+       SimpleOrderingTestPostingReordingDelayedTasks) {
+  PostTaskWhichPostsDelayedTask(1,
+                                base::TimeDelta::FromMilliseconds(1),
+                                base::TimeDelta::FromMilliseconds(20));
+  PostTaskWhichPostsDelayedTask(2,
+                                base::TimeDelta::FromMilliseconds(2),
+                                base::TimeDelta::FromMilliseconds(5));
+  PostTaskWhichPostsDelayedTask(3,
+                                base::TimeDelta::FromMilliseconds(3),
+                                base::TimeDelta::FromMilliseconds(5));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(1ms) 2(2ms) 3(3ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-2(7ms) -3(8ms) -1(21ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest,
+       SimpleOrderingTestPostingReordingDelayedTasksOverlap) {
+  PostTaskWhichPostsDelayedTask(1,
+                                base::TimeDelta::FromMilliseconds(1),
+                                base::TimeDelta::FromMilliseconds(5));
+  PostTaskWhichPostsDelayedTask(2,
+                                base::TimeDelta::FromMilliseconds(5),
+                                base::TimeDelta::FromMilliseconds(10));
+  PostTaskWhichPostsDelayedTask(3,
+                                base::TimeDelta::FromMilliseconds(10),
+                                base::TimeDelta::FromMilliseconds(1));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(1ms) 2(5ms)");
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "-1(6ms) 3(10ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-3(11ms) -2(15ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingAndRentrantTasks) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichCallsRun(2, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta());
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-1(0ms) -3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest,
+       SimpleOrderingTestPostingDelayedAndRentrantTasks) {
+  PostTaskWhichPostsDelayedTask(
+      1, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
+  PostTaskWhichCallsRun(2, base::TimeDelta());
+  PostTaskWhichPostsDelayedTask(
+      3, base::TimeDelta(), base::TimeDelta::FromMilliseconds(1));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-1(1ms) -3(1ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
 }
 
 TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasks) {
-  CreateAndPostTask(1, base::TimeDelta());
-  CreateAndPostTask(2, base::TimeDelta::FromMilliseconds(15));
-  CreateAndPostTask(3, base::TimeDelta());
-  CreateAndPostTask(4, base::TimeDelta::FromMilliseconds(8));
-
-  RunAndCheckResult("1 3 4 2");
+  PostTask(1, base::TimeDelta());
+  PostTask(2, base::TimeDelta::FromMilliseconds(15));
+  PostTask(3, base::TimeDelta());
+  PostTask(4, base::TimeDelta::FromMilliseconds(8));
+
+  RUN_AND_CHECK_RESULT(
+      false, RunPendingTasks(), "1(0ms) 3(0ms) 4(8ms) 2(15ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedPostingTasks) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(15));
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(4, base::TimeDelta::FromMilliseconds(8));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "-1(0ms) -3(0ms) 4(8ms)");
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "-4(8ms) 2(15ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "-2(15ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasksManualNow) {
+  task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+  PostTask(1, base::TimeDelta());
+  PostTask(2, base::TimeDelta::FromMilliseconds(15));
+  PostTask(3, base::TimeDelta());
+  PostTask(4, base::TimeDelta::FromMilliseconds(8));
+
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 3(0ms)");
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "");
+  EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
+            base::TimeDelta::FromMilliseconds(8));
+  now_src_->SetNow(base::TimeTicks::FromInternalValue(5000));
+  EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
+            base::TimeDelta::FromMilliseconds(3));
+  now_src_->SetNow(base::TimeTicks::FromInternalValue(25000));
+  EXPECT_EQ(task_runner_->DelayToNextTaskTime(), base::TimeDelta());
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "4(25ms) 2(25ms)");
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdle) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  RUN_AND_CHECK_RESULT(false, RunUntilIdle(), "1(0ms) -1(0ms)");
+  RUN_AND_CHECK_RESULT(false, RunUntilIdle(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeAutoNow) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
+
+  task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  base::TimeTicks run_at = base::TimeTicks();
+
+  run_at += base::TimeDelta::FromMilliseconds(2);
+  RUN_AND_CHECK_RESULT(
+      true, RunUntilTime(run_at), "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
+  EXPECT_EQ(run_at, now_src_->Now());
+
+  run_at += base::TimeDelta::FromMilliseconds(1);
+  RUN_AND_CHECK_RESULT(false, RunUntilTime(run_at), "3(3ms) -3(3ms)");
+  EXPECT_EQ(run_at, now_src_->Now());
+
+  run_at += base::TimeDelta::FromMilliseconds(1);
+  RUN_AND_CHECK_RESULT(false, RunUntilTime(run_at), "");
+  EXPECT_EQ(run_at, now_src_->Now());
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeManualNow) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
+
+  task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+
+  base::TimeTicks run_at = base::TimeTicks();
+
+  run_at += base::TimeDelta::FromMilliseconds(2);
+  RUN_AND_CHECK_RESULT(
+      true, RunUntilTime(run_at), "1(2ms) 2(2ms) -1(2ms) -2(2ms)");
+  EXPECT_EQ(run_at, now_src_->Now());
+
+  run_at += base::TimeDelta::FromMilliseconds(1);
+  RUN_AND_CHECK_RESULT(false, RunUntilTime(run_at), "3(3ms) -3(3ms)");
+  EXPECT_EQ(run_at, now_src_->Now());
+
+  run_at += base::TimeDelta::FromMilliseconds(1);
+  RUN_AND_CHECK_RESULT(false, RunUntilTime(run_at), "");
+  EXPECT_EQ(run_at, now_src_->Now());
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunForPeriod) {
+  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
+  PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
+  PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));
+
+  RUN_AND_CHECK_RESULT(true,
+                       RunForPeriod(base::TimeDelta::FromMilliseconds(2)),
+                       "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
+  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2),
+            now_src_->Now());
+
+  RUN_AND_CHECK_RESULT(false,
+                       RunForPeriod(base::TimeDelta::FromMilliseconds(1)),
+                       "3(3ms) -3(3ms)");
+  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
+            now_src_->Now());
+
+  RUN_AND_CHECK_RESULT(
+      false, RunForPeriod(base::TimeDelta::FromMilliseconds(1)), "");
+  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4),
+            now_src_->Now());
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunTasksWithCallback) {
+  base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
+  base::Callback<bool(void)> return_false = base::Bind(&ReturnFalse);
+
+  PostTask(1, base::TimeDelta());
+
+  RUN_AND_CHECK_RESULT(true, RunTasks(return_false), "");
+  RUN_AND_CHECK_RESULT(false, RunTasks(return_true), "1(0ms)");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, EmptyTaskList) {
+  RUN_AND_CHECK_RESULT(false, RunPendingTasks(), "");
+  RUN_AND_CHECK_RESULT(false, RunUntilIdle(), "");
+
+  ASSERT_EQ(base::TimeTicks(), now_src_->Now());
+
+  RUN_AND_CHECK_RESULT(
+      false, RunUntilTime(base::TimeTicks::FromInternalValue(100)), "");
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->Now());
+
+  RUN_AND_CHECK_RESULT(
+      false, RunForPeriod(base::TimeDelta::FromInternalValue(100)), "");
+  EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->Now());
+
+  base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
+  RUN_AND_CHECK_RESULT(false, RunTasks(return_true), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunPendingTasksTimeout) {
+  PostTask(1, base::TimeDelta());
+  PostTask(2, base::TimeDelta());
+  PostTask(3, base::TimeDelta());
+  PostTask(4, base::TimeDelta());
+  PostTask(5, base::TimeDelta());
+  PostTask(6, base::TimeDelta());
+
+  task_runner_->SetRunTaskLimit(3);
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
+
+  task_runner_->SetRunTaskLimit(2);
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "4(0ms) 5(0ms)");
+
+  task_runner_->SetRunTaskLimit(0);
+  RUN_AND_CHECK_RESULT(true, RunPendingTasks(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdleTimeout) {
+  PostTaskWhichPostsTaskAgain(1, base::TimeDelta::FromMilliseconds(3));
+
+  task_runner_->SetRunTaskLimit(3);
+  RUN_AND_CHECK_RESULT(true, RunUntilIdle(), "1(3ms) 1(6ms) 1(9ms)");
+
+  task_runner_->SetRunTaskLimit(2);
+  RUN_AND_CHECK_RESULT(true, RunUntilIdle(), "1(12ms) 1(15ms)");
+
+  task_runner_->SetRunTaskLimit(0);
+  RUN_AND_CHECK_RESULT(true, RunUntilIdle(), "");
+}
+
+TEST_F(OrderedSimpleTaskRunnerTest, RunUntilTimeout) {
+  base::TimeTicks run_to = base::TimeTicks() + base::TimeDelta::FromSeconds(1);
+
+  PostTask(1, base::TimeDelta::FromMilliseconds(1));
+  PostTask(2, base::TimeDelta::FromMilliseconds(2));
+  PostTask(3, base::TimeDelta::FromMilliseconds(3));
+  PostTask(4, base::TimeDelta::FromMilliseconds(4));
+  PostTask(5, base::TimeDelta::FromMilliseconds(5));
+
+  EXPECT_EQ(base::TimeTicks(), now_src_->Now());
+  task_runner_->SetRunTaskLimit(3);
+  RUN_AND_CHECK_RESULT(true, RunUntilTime(run_to), "1(1ms) 2(2ms) 3(3ms)");
+  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
+            now_src_->Now());
+
+  task_runner_->SetRunTaskLimit(0);
+  RUN_AND_CHECK_RESULT(true, RunUntilTime(run_to), "");
+
+  task_runner_->SetRunTaskLimit(100);
+  RUN_AND_CHECK_RESULT(false, RunUntilTime(run_to), "4(4ms) 5(5ms)");
+  EXPECT_EQ(run_to, now_src_->Now());
 }
 
 }  // namespace cc