TaskScheduler [5/9] Task Tracker

base/test/task_runner_test_template.h

 // Copyright (c) 2012 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.
 
 // This file defines tests that implementations of TaskRunner should
 // pass in order to be conformant, as well as test cases for optional behavior.
 // Here's how you use it to test your implementation.
 //
 // Say your class is called MyTaskRunner.  Then you need to define a
 // class called MyTaskRunnerTestDelegate in my_task_runner_unittest.cc
@@ skipping 54 matching lines @@
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner.h"
 #include "base/threading/thread.h"
 #include "base/tracked_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
-namespace internal {
+namespace testing {

[gab, 2016/03/09 21:53:26]

Missing rebase? Thought this change was made upstream already?

[fdoray, 2016/03/15 17:28:09]

Yes, missing rebase. I will rebase everything after my Task/Sequence CL gets
reviewed.

 
 // Utility class that keeps track of how many times particular tasks
 // are run.
 class TaskTracker : public RefCountedThreadSafe<TaskTracker> {
  public:
   TaskTracker();
 
   // Returns a closure that runs the given task and increments the run
   // count of |i| by one.  |task| may be null.  It is guaranteed that
   // only one task wrapped by a given tracker will be run at a time.
@@ skipping 12 matching lines @@
   void RunTask(const Closure& task, int i);
 
   mutable Lock lock_;
   std::map<int, int> task_run_counts_;
   int task_runs_;
   ConditionVariable task_runs_cv_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskTracker);
 };
 
-}  // namespace internal
+}  // namespace testing
 
 template <typename TaskRunnerTestDelegate>
-class TaskRunnerTest : public testing::Test {
+class TaskRunnerTest : public ::testing::Test {
  protected:
-  TaskRunnerTest() : task_tracker_(new internal::TaskTracker()) {}
+  TaskRunnerTest() : task_tracker_(new testing::TaskTracker()) {}
 
-  const scoped_refptr<internal::TaskTracker> task_tracker_;
+  const scoped_refptr<testing::TaskTracker> task_tracker_;
   TaskRunnerTestDelegate delegate_;
 };
 
 TYPED_TEST_CASE_P(TaskRunnerTest);
 
 // We can't really test much, since TaskRunner provides very few
 // guarantees.
 
 // Post a bunch of tasks to the task runner.  They should all
 // complete.
@@ skipping 38 matching lines @@
   this->delegate_.StopTaskRunner();
 
   EXPECT_EQ(expected_task_run_counts,
             this->task_tracker_->GetTaskRunCounts());
 }
 
 // The TaskRunnerTest test case verifies behaviour that is expected from a
 // task runner in order to be conformant.
 REGISTER_TYPED_TEST_CASE_P(TaskRunnerTest, Basic, Delayed);
 
-namespace internal {
+namespace testing {
 
 // Calls RunsTasksOnCurrentThread() on |task_runner| and expects it to
 // equal |expected_value|.
 void ExpectRunsTasksOnCurrentThread(
     bool expected_value,
     const scoped_refptr<TaskRunner>& task_runner);
 
-}  // namespace internal
+}  // namespace testing
 
 template <typename TaskRunnerTestDelegate>
 class TaskRunnerAffinityTest : public TaskRunnerTest<TaskRunnerTestDelegate> {};
 
 TYPED_TEST_CASE_P(TaskRunnerAffinityTest);
 
 // Post a bunch of tasks to the task runner as well as to a separate
 // thread, each checking the value of RunsTasksOnCurrentThread(),
 // which should return true for the tasks posted on the task runner
 // and false for the tasks posted on the separate thread.
 TYPED_TEST_P(TaskRunnerAffinityTest, RunsTasksOnCurrentThread) {
   std::map<int, int> expected_task_run_counts;
 
   Thread thread("Non-task-runner thread");
   ASSERT_TRUE(thread.Start());
   this->delegate_.StartTaskRunner();
 
   scoped_refptr<TaskRunner> task_runner = this->delegate_.GetTaskRunner();
   // Post each ith task i+1 times on the task runner and i+1 times on
   // the non-task-runner thread.
   for (int i = 0; i < 20; ++i) {
-    const Closure& ith_task_runner_task =
-        this->task_tracker_->WrapTask(
-            Bind(&internal::ExpectRunsTasksOnCurrentThread,
-                 true, task_runner),
-            i);
-    const Closure& ith_non_task_runner_task =
-        this->task_tracker_->WrapTask(
-            Bind(&internal::ExpectRunsTasksOnCurrentThread,
-                 false, task_runner),
-            i);
+    const Closure& ith_task_runner_task = this->task_tracker_->WrapTask(
+        Bind(&testing::ExpectRunsTasksOnCurrentThread, true, task_runner), i);
+    const Closure& ith_non_task_runner_task = this->task_tracker_->WrapTask(
+        Bind(&testing::ExpectRunsTasksOnCurrentThread, false, task_runner), i);
     for (int j = 0; j < i + 1; ++j) {
       task_runner->PostTask(FROM_HERE, ith_task_runner_task);
       thread.task_runner()->PostTask(FROM_HERE, ith_non_task_runner_task);
       expected_task_run_counts[i] += 2;
     }
   }
 
   this->delegate_.StopTaskRunner();
   thread.Stop();
 
   EXPECT_EQ(expected_task_run_counts,
             this->task_tracker_->GetTaskRunCounts());
 }
 
 // TaskRunnerAffinityTest tests that the TaskRunner implementation
 // can determine if tasks will never be run on a specific thread.
 REGISTER_TYPED_TEST_CASE_P(TaskRunnerAffinityTest, RunsTasksOnCurrentThread);
 
 }  // namespace base
 
 #endif  // BASE_TEST_TASK_RUNNER_TEST_TEMPLATE_H_