scoped_mock_time_message_loop_task_runner_unittest.cc 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126
  1. // Copyright 2015 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. #include "base/test/scoped_mock_time_message_loop_task_runner.h"
  5. #include <memory>
  6. #include "base/bind.h"
  7. #include "base/callback_helpers.h"
  8. #include "base/containers/circular_deque.h"
  9. #include "base/memory/ptr_util.h"
  10. #include "base/memory/ref_counted.h"
  11. #include "base/task/current_thread.h"
  12. #include "base/test/task_environment.h"
  13. #include "base/test/test_mock_time_task_runner.h"
  14. #include "base/test/test_pending_task.h"
  15. #include "base/threading/thread_task_runner_handle.h"
  16. #include "base/time/time.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. namespace base {
  19. namespace {
  20. TaskRunner* GetCurrentTaskRunner() {
  21. return ThreadTaskRunnerHandle::Get().get();
  22. }
  23. void AssignTrue(bool* out) {
  24. *out = true;
  25. }
  26. // Pops a task from the front of |pending_tasks| and returns it.
  27. TestPendingTask PopFront(base::circular_deque<TestPendingTask>* pending_tasks) {
  28. TestPendingTask task = std::move(pending_tasks->front());
  29. pending_tasks->pop_front();
  30. return task;
  31. }
  32. class ScopedMockTimeMessageLoopTaskRunnerTest : public testing::Test {
  33. public:
  34. ScopedMockTimeMessageLoopTaskRunnerTest()
  35. : original_task_runner_(new TestMockTimeTaskRunner()) {
  36. CurrentThread::Get()->SetTaskRunner(original_task_runner_);
  37. }
  38. ScopedMockTimeMessageLoopTaskRunnerTest(
  39. const ScopedMockTimeMessageLoopTaskRunnerTest&) = delete;
  40. ScopedMockTimeMessageLoopTaskRunnerTest& operator=(
  41. const ScopedMockTimeMessageLoopTaskRunnerTest&) = delete;
  42. protected:
  43. TestMockTimeTaskRunner* original_task_runner() {
  44. return original_task_runner_.get();
  45. }
  46. private:
  47. scoped_refptr<TestMockTimeTaskRunner> original_task_runner_;
  48. test::SingleThreadTaskEnvironment task_environment_;
  49. };
  50. // Verifies a new TaskRunner is installed while a
  51. // ScopedMockTimeMessageLoopTaskRunner exists and the previous one is installed
  52. // after destruction.
  53. TEST_F(ScopedMockTimeMessageLoopTaskRunnerTest, CurrentTaskRunners) {
  54. auto scoped_task_runner_ =
  55. std::make_unique<ScopedMockTimeMessageLoopTaskRunner>();
  56. EXPECT_EQ(scoped_task_runner_->task_runner(), GetCurrentTaskRunner());
  57. scoped_task_runner_.reset();
  58. EXPECT_EQ(original_task_runner(), GetCurrentTaskRunner());
  59. }
  60. TEST_F(ScopedMockTimeMessageLoopTaskRunnerTest,
  61. IncompleteTasksAreCopiedToPreviousTaskRunnerAfterDestruction) {
  62. auto scoped_task_runner_ =
  63. std::make_unique<ScopedMockTimeMessageLoopTaskRunner>();
  64. bool task_10_has_run = false;
  65. bool task_11_has_run = false;
  66. OnceClosure task_1 = DoNothing();
  67. OnceClosure task_2 = DoNothing();
  68. OnceClosure task_10 = BindOnce(&AssignTrue, &task_10_has_run);
  69. OnceClosure task_11 = BindOnce(&AssignTrue, &task_11_has_run);
  70. constexpr TimeDelta task_1_delay = Seconds(1);
  71. constexpr TimeDelta task_2_delay = Seconds(2);
  72. constexpr TimeDelta task_10_delay = Seconds(10);
  73. constexpr TimeDelta task_11_delay = Seconds(11);
  74. constexpr TimeDelta step_time_by = Seconds(5);
  75. GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, std::move(task_1),
  76. task_1_delay);
  77. GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, std::move(task_2),
  78. task_2_delay);
  79. GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, std::move(task_10),
  80. task_10_delay);
  81. GetCurrentTaskRunner()->PostDelayedTask(FROM_HERE, std::move(task_11),
  82. task_11_delay);
  83. scoped_task_runner_->task_runner()->FastForwardBy(step_time_by);
  84. scoped_task_runner_.reset();
  85. base::circular_deque<TestPendingTask> pending_tasks =
  86. original_task_runner()->TakePendingTasks();
  87. EXPECT_EQ(2U, pending_tasks.size());
  88. TestPendingTask pending_task = PopFront(&pending_tasks);
  89. EXPECT_FALSE(task_10_has_run);
  90. std::move(pending_task.task).Run();
  91. EXPECT_TRUE(task_10_has_run);
  92. EXPECT_EQ(task_10_delay - step_time_by, pending_task.delay);
  93. pending_task = PopFront(&pending_tasks);
  94. EXPECT_FALSE(task_11_has_run);
  95. std::move(pending_task.task).Run();
  96. EXPECT_TRUE(task_11_has_run);
  97. EXPECT_EQ(task_11_delay - step_time_by, pending_task.delay);
  98. }
  99. } // namespace
  100. } // namespace base