// 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/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"

// We pass EXPECT_TRUE / EXPECT_FALSE macros rather than a boolean as on some
// compilers EXPECT_EQ(false, XXXX) fails to compile as  gtest tries to convert
// the false value to null causing a -Werror=conversion-null error.
#define RUN_AND_CHECK_RESULT(                             \
    tasks_remain_expect_macro, run_func, expected_result) \
  tasks_remain_expect_macro(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()
      : now_src_(new base::SimpleTestTickClock()),
        task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)) {}
  ~OrderedSimpleTaskRunnerTest() override {}

 protected:
  std::string executed_tasks_;
  scoped_ptr<base::SimpleTestTickClock> 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 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:
  void Task(int task_num) {
    if (!executed_tasks_.empty())
      executed_tasks_ += " ";
    executed_tasks_ += base::StringPrintf(
        "%d(%" PRId64 "ms)", task_num,
        (now_src_->NowTicks() - base::TimeTicks()).InMilliseconds());
  }

  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, SimpleOrderingTest) {
  PostTask(1, base::TimeDelta());
  PostTask(2, base::TimeDelta());
  PostTask(3, base::TimeDelta());

  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");

  PostTask(4, base::TimeDelta());
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
}

TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingTasks) {
  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
  PostTaskWhichPostsInstantTask(2, base::TimeDelta());
  PostTaskWhichPostsInstantTask(3, base::TimeDelta());

  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -2(0ms) -3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -2(1ms) -3(1ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(2ms) 3(3ms)");
  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunPendingTasks(), "-2(7ms) -3(8ms) -1(21ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(1ms) 2(5ms)");
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-1(6ms) 3(10ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-3(11ms) -2(15ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
}

TEST_F(OrderedSimpleTaskRunnerTest, SimpleOrderingTestPostingAndRentrantTasks) {
  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
  PostTaskWhichCallsRun(2, base::TimeDelta());
  PostTaskWhichPostsInstantTask(3, base::TimeDelta());

  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(0ms) -3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-1(1ms) -3(1ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
}

TEST_F(OrderedSimpleTaskRunnerTest, OrderingTestWithDelayedTasks) {
  PostTask(1, base::TimeDelta());
  PostTask(2, base::TimeDelta::FromMilliseconds(15));
  PostTask(3, base::TimeDelta());
  PostTask(4, base::TimeDelta::FromMilliseconds(8));

  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunPendingTasks(), "1(0ms) 3(0ms) 4(8ms) 2(15ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(
      EXPECT_TRUE, RunPendingTasks(), "-1(0ms) -3(0ms) 4(8ms)");
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "-4(8ms) 2(15ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "-2(15ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 3(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "");
  EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
            base::TimeDelta::FromMilliseconds(8));
  now_src_->Advance(base::TimeDelta::FromMicroseconds(5000));
  EXPECT_EQ(task_runner_->DelayToNextTaskTime(),
            base::TimeDelta::FromMilliseconds(3));
  now_src_->Advance(base::TimeDelta::FromMicroseconds(20000));
  EXPECT_EQ(task_runner_->DelayToNextTaskTime(), base::TimeDelta());
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "4(25ms) 2(25ms)");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
}

TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdle) {
  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "1(0ms) -1(0ms)");
  RUN_AND_CHECK_RESULT(EXPECT_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(
      EXPECT_TRUE, RunUntilTime(run_at), "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
  EXPECT_EQ(run_at, now_src_->NowTicks());

  run_at += base::TimeDelta::FromMilliseconds(1);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
  EXPECT_EQ(run_at, now_src_->NowTicks());

  run_at += base::TimeDelta::FromMilliseconds(1);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
  EXPECT_EQ(run_at, now_src_->NowTicks());
}

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(
      EXPECT_TRUE, RunUntilTime(run_at), "1(2ms) 2(2ms) -1(2ms) -2(2ms)");
  EXPECT_EQ(run_at, now_src_->NowTicks());

  run_at += base::TimeDelta::FromMilliseconds(1);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "3(3ms) -3(3ms)");
  EXPECT_EQ(run_at, now_src_->NowTicks());

  run_at += base::TimeDelta::FromMilliseconds(1);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_at), "");
  EXPECT_EQ(run_at, now_src_->NowTicks());
}

TEST_F(OrderedSimpleTaskRunnerTest, RunForPeriod) {
  PostTaskWhichPostsInstantTask(1, base::TimeDelta());
  PostTaskWhichPostsInstantTask(2, base::TimeDelta::FromMilliseconds(2));
  PostTaskWhichPostsInstantTask(3, base::TimeDelta::FromMilliseconds(3));

  RUN_AND_CHECK_RESULT(EXPECT_TRUE,
                       RunForPeriod(base::TimeDelta::FromMilliseconds(2)),
                       "1(0ms) -1(0ms) 2(2ms) -2(2ms)");
  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(2),
            now_src_->NowTicks());

  RUN_AND_CHECK_RESULT(EXPECT_FALSE,
                       RunForPeriod(base::TimeDelta::FromMilliseconds(1)),
                       "3(3ms) -3(3ms)");
  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
            now_src_->NowTicks());

  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromMilliseconds(1)), "");
  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(4),
            now_src_->NowTicks());
}

TEST_F(OrderedSimpleTaskRunnerTest, RunTasksWhileWithCallback) {
  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(EXPECT_TRUE, RunTasksWhile(return_false), "");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(return_true), "1(0ms)");
}

TEST_F(OrderedSimpleTaskRunnerTest, EmptyTaskList) {
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunPendingTasks(), "");
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilIdle(), "");

  ASSERT_EQ(base::TimeTicks(), now_src_->NowTicks());

  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunUntilTime(base::TimeTicks::FromInternalValue(100)), "");
  EXPECT_EQ(base::TimeTicks::FromInternalValue(100), now_src_->NowTicks());

  RUN_AND_CHECK_RESULT(
      EXPECT_FALSE, RunForPeriod(base::TimeDelta::FromInternalValue(100)), "");
  EXPECT_EQ(base::TimeTicks::FromInternalValue(200), now_src_->NowTicks());

  base::Callback<bool(void)> return_true = base::Bind(&ReturnTrue);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunTasksWhile(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(EXPECT_TRUE, RunPendingTasks(), "1(0ms) 2(0ms) 3(0ms)");

  task_runner_->SetRunTaskLimit(2);
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "4(0ms) 5(0ms)");

  task_runner_->SetRunTaskLimit(0);
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunPendingTasks(), "");
}

TEST_F(OrderedSimpleTaskRunnerTest, RunUntilIdleTimeout) {
  PostTaskWhichPostsTaskAgain(1, base::TimeDelta::FromMilliseconds(3));

  task_runner_->SetRunTaskLimit(3);
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(3ms) 1(6ms) 1(9ms)");

  task_runner_->SetRunTaskLimit(2);
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilIdle(), "1(12ms) 1(15ms)");

  task_runner_->SetRunTaskLimit(0);
  RUN_AND_CHECK_RESULT(EXPECT_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_->NowTicks());
  task_runner_->SetRunTaskLimit(3);
  RUN_AND_CHECK_RESULT(
      EXPECT_TRUE, RunUntilTime(run_to), "1(1ms) 2(2ms) 3(3ms)");
  EXPECT_EQ(base::TimeTicks() + base::TimeDelta::FromMilliseconds(3),
            now_src_->NowTicks());

  task_runner_->SetRunTaskLimit(0);
  RUN_AND_CHECK_RESULT(EXPECT_TRUE, RunUntilTime(run_to), "");

  task_runner_->SetRunTaskLimit(100);
  RUN_AND_CHECK_RESULT(EXPECT_FALSE, RunUntilTime(run_to), "4(4ms) 5(5ms)");
  EXPECT_EQ(run_to, now_src_->NowTicks());
}

}  // namespace cc