GTTF: TestLauncher: asynchronous and out-of-order execution of tests

content/public/test/test_launcher.cc

 // 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.
 
 #include "content/public/test/test_launcher.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 212 matching lines @@
   explicit WrapperTestLauncherDelegate(
       content::TestLauncherDelegate* launcher_delegate)
       : launcher_delegate_(launcher_delegate),
         timeout_count_(0),
         printed_timeout_message_(false) {
   }
 
   // base::TestLauncherDelegate:
   virtual bool ShouldRunTest(const testing::TestCase* test_case,
                              const testing::TestInfo* test_info) OVERRIDE;
-  virtual bool RunTest(const testing::TestCase* test_case,
-                       const testing::TestInfo* test_info) OVERRIDE;
+  virtual void RunTest(
+      const testing::TestCase* test_case,
+      const testing::TestInfo* test_info,
+      const base::TestLauncherDelegate::TestResultCallback& callback) OVERRIDE;
+  virtual void RunRemainingTests() OVERRIDE;
 
  private:
   content::TestLauncherDelegate* launcher_delegate_;
 
   // Number of times a test timeout occurred.
   size_t timeout_count_;
 
   // True after a message about too many timeouts has been printed,
   // to avoid doing it more than once.
   bool printed_timeout_message_;
@@ skipping 20 matching lines @@
     if (!printed_timeout_message_) {
       printed_timeout_message_ = true;
       printf("Too many timeouts, aborting test\n");
     }
     return false;
   }
 
   return true;
 }
 
-bool WrapperTestLauncherDelegate::RunTest(const testing::TestCase* test_case,
-                                          const testing::TestInfo* test_info) {
+void WrapperTestLauncherDelegate::RunTest(
+    const testing::TestCase* test_case,
+    const testing::TestInfo* test_info,
+    const base::TestLauncherDelegate::TestResultCallback& callback) {
+  base::TimeTicks start_time = base::TimeTicks::Now();
   bool was_timeout = false;
   std::string test_name =
       std::string(test_case->name()) + "." + test_info->name();
   int exit_code = DoRunTest(launcher_delegate_,
                             test_case,
                             test_name,
                             TestTimeouts::action_max_timeout(),
                             &was_timeout);
   if (was_timeout)
     timeout_count_++;
-  return exit_code == 0;
+
+  base::TestResult result;
+  result.test_case_name = test_case->name();
+  result.test_name = test_info->name();
+  result.success = (exit_code == 0);
+  result.elapsed_time = (base::TimeTicks::Now() - start_time);
+
+  callback.Run(result);
+}
+
+void WrapperTestLauncherDelegate::RunRemainingTests() {
+  // No need to do anything here, we launch tests synchronously.
 }
 
 }  // namespace
 
 // The following is kept for historical reasons (so people that are used to
 // using it don't get surprised).
 const char kChildProcessFlag[]   = "child";
 
 const char kGTestHelpFlag[]   = "gtest_help";
 
@@ skipping 87 matching lines @@
 
   WrapperTestLauncherDelegate delegate(launcher_delegate);
   return base::LaunchTests(&delegate, argc, argv);
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 }  // namespace content