GTTF: Add command-line switches for number of jobs and batch limit.

base/test/unit_test_launcher.cc

 // Copyright 2013 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 "base/test/unit_test_launcher.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
+#include "base/sys_info.h"
 #include "base/test/gtest_xml_util.h"
 #include "base/test/parallel_test_launcher.h"
 #include "base/test/test_launcher.h"
 #include "base/test/test_switches.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_checker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 namespace {
 
-// This constant controls how many tests are run in a single batch.
-const size_t kTestBatchLimit = 10;
+// This constant controls how many tests are run in a single batch by default.
+const size_t kDefaultTestBatchLimit = 10;
 
 // Flag to enable the new launcher logic.
 // TODO(phajdan.jr): Remove it, http://crbug.com/236893 .
 const char kBraveNewTestLauncherFlag[] = "brave-new-test-launcher";
 
 // Flag to run all tests in a single process.
 const char kSingleProcessTestsFlag[] = "single-process-tests";
 
 // Returns command line for child GTest process based on the command line
 // of current process. |test_names| is a vector of test full names
 // (e.g. "A.B"), |output_file| is path to the GTest XML output file.
 CommandLine GetCommandLineForChildGTestProcess(
     const std::vector<std::string>& test_names,
     const base::FilePath& output_file) {
   CommandLine new_cmd_line(*CommandLine::ForCurrentProcess());
 
   new_cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file);
   new_cmd_line.AppendSwitchASCII(kGTestFilterFlag, JoinString(test_names, ":"));
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
   new_cmd_line.AppendSwitch(kBraveNewTestLauncherFlag);
 
   return new_cmd_line;
 }
 
 class UnitTestLauncherDelegate : public TestLauncherDelegate {
  public:
-  explicit UnitTestLauncherDelegate(size_t jobs) : parallel_launcher_(jobs) {
+  UnitTestLauncherDelegate(size_t jobs, size_t batch_limit)
+      : parallel_launcher_(jobs),
+        batch_limit_(batch_limit) {
   }
 
   virtual ~UnitTestLauncherDelegate() {
     DCHECK(thread_checker_.CalledOnValidThread());
   }
 
  private:
   struct TestLaunchInfo {
     std::string GetFullName() const {
       return test_case_name + "." + test_name;
@@ skipping 17 matching lines @@
                        const TestResultCallback& callback) OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     TestLaunchInfo launch_info;
     launch_info.test_case_name = test_case->name();
     launch_info.test_name = test_info->name();
     launch_info.callback = callback;
     tests_.push_back(launch_info);
 
     // Run tests in batches no larger than the limit.
-    if (tests_.size() >= kTestBatchLimit)
+    if (tests_.size() >= batch_limit_)
       RunRemainingTests();
   }
 
   virtual void RunRemainingTests() OVERRIDE {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     if (tests_.empty())
       return;
 
     // Create a dedicated temporary directory to store the xml result data
@@ skipping 167 matching lines @@
         tests[i].callback.Run(test_result);
         called_any_callback = true;
       }
     }
 
     return called_any_callback;
   }
 
   ParallelTestLauncher parallel_launcher_;
 
+  // Maximum number of tests to run in a single batch.
+  size_t batch_limit_;
+
   std::vector<TestLaunchInfo> tests_;
 
   ThreadChecker thread_checker_;
 };
 
+bool GetSwitchValueAsInt(const std::string& switch_name, int* result) {
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(switch_name))
+    return true;
+
+  std::string switch_value =
+      CommandLine::ForCurrentProcess()->GetSwitchValueASCII(switch_name);
+  if (!StringToInt(switch_value, result) || *result < 1) {
+    LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value;
+    return false;
+  }
+
+  return true;
+}
+
 }  // namespace
 
 int LaunchUnitTests(int argc,
                     char** argv,
                     const RunTestSuiteCallback& run_test_suite) {
   CommandLine::Init(argc, argv);
   if (CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcessTestsFlag) ||
       !CommandLine::ForCurrentProcess()->HasSwitch(kBraveNewTestLauncherFlag)) {
     return run_test_suite.Run();
   }
 
   base::TimeTicks start_time(base::TimeTicks::Now());
 
-  fprintf(stdout,
-      "Starting tests...\n"
-      "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their own \n"
-      "process. For debugging a test inside a debugger, use the\n"
-      "--gtest_filter=<your_test_name> flag along with \n"
-      "--single-process-tests.\n");
-  fflush(stdout);
-
   testing::InitGoogleTest(&argc, argv);
   TestTimeouts::Initialize();
 
+  int jobs = SysInfo::NumberOfProcessors();
+  if (!GetSwitchValueAsInt(switches::kTestLauncherJobs, &jobs))
+    return 1;
+
+  int batch_limit = kDefaultTestBatchLimit;
+  if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit))
+    return 1;
+
+  fprintf(stdout,
+          "Starting tests (using %d parallel jobs)...\n"
+          "IMPORTANT DEBUGGING NOTE: batches of tests are run inside their\n"
+          "own process. For debugging a test inside a debugger, use the\n"
+          "--gtest_filter=<your_test_name> flag along with\n"
+          "--single-process-tests.\n", jobs);
+  fflush(stdout);
+
   MessageLoop message_loop;
 
-  // TODO(phajdan.jr): Provide an option to adjust jobs, default to number
-  // of CPU cores.
-  base::UnitTestLauncherDelegate delegate(4);
+  base::UnitTestLauncherDelegate delegate(jobs, batch_limit);
   int exit_code = base::LaunchTests(&delegate, argc, argv);
 
   fprintf(stdout,
           "Tests took %" PRId64 " seconds.\n",
           (base::TimeTicks::Now() - start_time).InSeconds());
   fflush(stdout);
 
   return exit_code;
 }
 
 }  // namespace base