Flush SequenceWorkerPool tasks after each unit test.

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 class defines tests that implementations of TaskRunner should
 // pass in order to be conformant.  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
 // like this:
 //
 //   class MyTaskRunnerTestDelegate {
 //    public:
 //     // Tasks posted to the task runner after this and before
 //     // StopTaskRunner() is called is called should run successfully.
 //     void StartTaskRunner() {
 //       ...
 //     }
 //
 //     // Should return the task runner implementation.  Only called
 //     // after StartTaskRunner and before StopTaskRunner.
 //     scoped_refptr<MyTaskRunner> GetTaskRunner() {
 //       ...
 //     }
 //
 //     // Stop the task runner and make sure all tasks posted before
-//     // this is called are run.
+//     // this is called are run. Caveat: delayed tasks are not run,
+       // they're simply deleted.
 //     void StopTaskRunner() {
 //       ...
 //     }
 //
 //     // Returns whether or not the task runner obeys non-zero delays.
 //     bool TaskRunnerHandlesNonZeroDelays() const {
 //       return true;
 //     }
 //   };
 //
@@ skipping 12 matching lines @@
 #ifndef BASE_TEST_TASK_RUNNER_TEST_TEMPLATE_H_
 #define BASE_TEST_TASK_RUNNER_TEST_TEMPLATE_H_
 
 #include <cstddef>
 #include <map>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.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 {
 
 // 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.
   Closure WrapTask(const Closure& task, int i);
 
   std::map<int, int> GetTaskRunCounts() const;
 
+  // Returns after the tracker observes a total of |count| task completions.
+  void WaitForCompletedTasks(int count);
+
  private:
   friend class RefCountedThreadSafe<TaskTracker>;
 
   ~TaskTracker();
 
   void RunTask(const Closure& task, int i);
 
-  mutable Lock task_run_counts_lock_;
+  mutable Lock lock_;
   std::map<int, int> task_run_counts_;
+  int task_runs_;
+  ConditionVariable task_runs_cv_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskTracker);
 };
 
 }  // namespace internal
 
 template <typename TaskRunnerTestDelegate>
 class TaskRunnerTest : public testing::Test {
  protected:
   TaskRunnerTest() : task_tracker_(new internal::TaskTracker()) {}
@@ skipping 30 matching lines @@
 
 // Post a bunch of delayed tasks to the task runner.  They should all
 // complete.
 TYPED_TEST_P(TaskRunnerTest, Delayed) {
   if (!this->delegate_.TaskRunnerHandlesNonZeroDelays()) {
     DLOG(INFO) << "This TaskRunner doesn't handle non-zero delays; skipping";
     return;
   }
 
   std::map<int, int> expected_task_run_counts;
+  int expected_total_tasks = 0;
 
   this->delegate_.StartTaskRunner();
   scoped_refptr<TaskRunner> task_runner = this->delegate_.GetTaskRunner();
   // Post each ith task i+1 times with delays from 0-i.
   for (int i = 0; i < 20; ++i) {
     const Closure& ith_task = this->task_tracker_->WrapTask(Closure(), i);
     for (int j = 0; j < i + 1; ++j) {
       task_runner->PostDelayedTask(
           FROM_HERE, ith_task, base::TimeDelta::FromMilliseconds(j));
       ++expected_task_run_counts[i];
+      ++expected_total_tasks;
     }
   }
+  this->task_tracker_->WaitForCompletedTasks(expected_total_tasks);
   this->delegate_.StopTaskRunner();
 
   EXPECT_EQ(expected_task_run_counts,
             this->task_tracker_->GetTaskRunCounts());
 }
 
 namespace internal {
 
 // Calls RunsTasksOnCurrentThread() on |task_runner| and expects it to
 // equal |expected_value|.
@@ skipping 41 matching lines @@
   EXPECT_EQ(expected_task_run_counts,
             this->task_tracker_->GetTaskRunCounts());
 }
 
 REGISTER_TYPED_TEST_CASE_P(
     TaskRunnerTest, Basic, Delayed, RunsTasksOnCurrentThread);
 
 }  // namespace base
 
 #endif  //#define BASE_TEST_TASK_RUNNER_TEST_TEMPLATE_H_