GTTF: Fix handling of PRE_ 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 <map>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 85 matching lines @@
   virtual bool ShouldRunTest(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:
   struct TestInfo {
+    std::string GetFullName() const { return test_case_name + "." + test_name; }
+
     std::string test_case_name;
     std::string test_name;
-    base::TestLauncherDelegate::TestResultCallback callback;
+    std::vector<base::TestLauncherDelegate::TestResultCallback> callbacks;
   };
 
-  friend bool CompareTestInfo(const TestInfo& a, const TestInfo& b);
-
   // Launches test from |test_info| using |command_line| and parallel launcher.
   void DoRunTest(const TestInfo& test_info, const CommandLine& command_line);
 
+  // Launches test named |test_name| using |command_line| and parallel launcher,
+  // given result of PRE_ test |pre_test_result|.
+  void RunDependentTest(const std::string test_name,
+                        const CommandLine& command_line,
+                        const base::TestResult& pre_test_result);
+
   // Callback to receive result of a test.
   void GTestCallback(
       const TestInfo& test_info,
       int exit_code,
       const base::TimeDelta& elapsed_time,
       bool was_timeout,
       const std::string& output);
 
   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_;
 
   base::ParallelTestLauncher parallel_launcher_;
 
   // Store all tests to run before running any of them to properly
-  // handle PRE_ tests.
-  std::vector<TestInfo> tests_to_run_;
+  // handle PRE_ tests. The map is indexed by test full name (e.g. "A.B").
+  typedef std::map<std::string, TestInfo> TestInfoMap;
+  TestInfoMap tests_to_run_;
 
   // Temporary directory for user data directories.
   base::ScopedTempDir temp_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(WrapperTestLauncherDelegate);
 };
 
 std::string WrapperTestLauncherDelegate::GetTestNameForFiltering(
     const testing::TestCase* test_case,
     const testing::TestInfo* test_info) {
@@ skipping 21 matching lines @@
   return true;
 }
 
 void WrapperTestLauncherDelegate::RunTest(
     const testing::TestCase* test_case,
     const testing::TestInfo* test_info,
     const base::TestLauncherDelegate::TestResultCallback& callback) {
   TestInfo run_test_info;
   run_test_info.test_case_name = test_case->name();
   run_test_info.test_name = test_info->name();
-  run_test_info.callback = callback;
-  tests_to_run_.push_back(run_test_info);
-}
+  run_test_info.callbacks.push_back(callback);
 
-bool CompareTestInfo(const WrapperTestLauncherDelegate::TestInfo& a,
-                     const WrapperTestLauncherDelegate::TestInfo& b) {
-  if (a.test_case_name == b.test_case_name) {
-    // Put PRE_ tests before tests that depend on them (e.g. PRE_Foo before Foo,
-    // and PRE_PRE_Foo before PRE_Foo).
-    if (std::string(kPreTestPrefix) + a.test_name == b.test_name)
-      return false;
-    if (a.test_name == std::string(kPreTestPrefix) + b.test_name)
-      return true;
-  }
-
-  // Otherwise sort by full names, disregarding PRE_ completely so that
-  // this can still be Strict Weak Ordering.
-  std::string a_full(
-      RemoveAnyPrePrefixes(a.test_case_name + "." + a.test_name));
-  std::string b_full(
-      RemoveAnyPrePrefixes(b.test_case_name + "." + b.test_name));
-
-  return a_full < b_full;
+  DCHECK(!ContainsKey(tests_to_run_, run_test_info.GetFullName()));
+  tests_to_run_[run_test_info.GetFullName()] = run_test_info;
 }
 
 void WrapperTestLauncherDelegate::RunRemainingTests() {
-  std::sort(tests_to_run_.begin(), tests_to_run_.end(), CompareTestInfo);
-
   // PRE_ tests and tests that depend on them must share the same
   // data directory. Using test name as directory name leads to too long
   // names (exceeding UNIX_PATH_MAX, which creates a problem with
   // process_singleton_linux). Create a randomly-named temporary directory
   // and keep track of the names so that PRE_ tests can still re-use them.
   std::map<std::string, base::FilePath> temp_directories;
 
-  for (size_t i = 0; i < tests_to_run_.size(); i++) {
-    TestInfo test_info(tests_to_run_[i]);
+  // List of tests we can kick off right now, depending on no other tests.
+  std::vector<std::pair<std::string, CommandLine> > tests_to_run_now;
+
+  for (TestInfoMap::iterator i = tests_to_run_.begin();
+       i != tests_to_run_.end();
+       ++i) {
+    const TestInfo& test_info = i->second;
 
     // Make sure PRE_ tests and tests that depend on them share the same
     // data directory - based it on the test name without prefixes.
-    std::string test_name_no_pre = RemoveAnyPrePrefixes(
-        test_info.test_case_name + "." + test_info.test_name);
+    std::string test_name_no_pre(RemoveAnyPrePrefixes(test_info.GetFullName()));
     if (!ContainsKey(temp_directories, test_name_no_pre)) {
       base::FilePath temp_dir;
       CHECK(file_util::CreateTemporaryDirInDir(
                 temp_dir_.path(), FILE_PATH_LITERAL("d"), &temp_dir));
       temp_directories[test_name_no_pre] = temp_dir;
     }
 
     CommandLine new_cmd_line(*CommandLine::ForCurrentProcess());
     CHECK(launcher_delegate_->AdjustChildProcessCommandLine(
               &new_cmd_line, temp_directories[test_name_no_pre]));
 
-    DoRunTest(test_info, new_cmd_line);
+    std::string pre_test_name(
+        test_info.test_case_name + "." + kPreTestPrefix + test_info.test_name);
+    if (ContainsKey(tests_to_run_, pre_test_name)) {
+      tests_to_run_[pre_test_name].callbacks.push_back(
+          base::Bind(&WrapperTestLauncherDelegate::RunDependentTest,
+                     base::Unretained(this),
+                     test_info.GetFullName(),
+                     new_cmd_line));
+    } else {
+      tests_to_run_now.push_back(
+          std::make_pair(test_info.GetFullName(), new_cmd_line));
+    }
+  }
+
+  for (size_t i = 0; i < tests_to_run_now.size(); i++) {
+    const TestInfo& test_info = tests_to_run_[tests_to_run_now[i].first];
+    const CommandLine& cmd_line = tests_to_run_now[i].second;
+    DoRunTest(test_info, cmd_line);
   }
 }
 
 void WrapperTestLauncherDelegate::DoRunTest(const TestInfo& test_info,
                                             const CommandLine& command_line) {
   CommandLine new_cmd_line(command_line.GetProgram());
   CommandLine::SwitchMap switches = command_line.GetSwitches();
 
   // Strip out gtest_output flag because otherwise we would overwrite results
   // of the other tests.
@@ skipping 12 matching lines @@
       test_info.test_case_name + "." + test_info.test_name);
   new_cmd_line.AppendSwitch(kSingleProcessTestsFlag);
 
   char* browser_wrapper = getenv("BROWSER_WRAPPER");
 
   // PRE_ tests and tests that depend on them should share the sequence token
   // name, so that they are run serially.
   std::string test_name_no_pre = RemoveAnyPrePrefixes(
       test_info.test_case_name + "." + test_info.test_name);
 
-  parallel_launcher_.LaunchNamedSequencedChildGTestProcess(
-      test_name_no_pre,
+  parallel_launcher_.LaunchChildGTestProcess(
       new_cmd_line,
       browser_wrapper ? browser_wrapper : std::string(),
       TestTimeouts::action_max_timeout(),
       base::Bind(&WrapperTestLauncherDelegate::GTestCallback,
                  base::Unretained(this),
                  test_info));
 }
 
+void WrapperTestLauncherDelegate::RunDependentTest(
+    const std::string test_name,
+    const CommandLine& command_line,
+    const base::TestResult& pre_test_result) {
+  const TestInfo& test_info = tests_to_run_[test_name];
+  if (pre_test_result.status == base::TestResult::TEST_SUCCESS) {
+    // Only run the dependent test if PRE_ test succeeded.
+    DoRunTest(test_info, command_line);
+  } else {
+    // Otherwise skip the test.
+    base::TestResult test_result;
+    test_result.test_case_name = test_info.test_case_name;
+    test_result.test_name = test_info.test_name;
+    test_result.status = base::TestResult::TEST_SKIPPED;
+    for (size_t i = 0; i < test_info.callbacks.size(); i++)
+      test_info.callbacks[i].Run(test_result);
+  }
+}
+
 void WrapperTestLauncherDelegate::GTestCallback(
     const TestInfo& test_info,
     int exit_code,
     const base::TimeDelta& elapsed_time,
     bool was_timeout,
     const std::string& output) {
   base::TestResult result;
   result.test_case_name = test_info.test_case_name;
   result.test_name = test_info.test_name;
 
   // TODO(phajdan.jr): Recognize crashes.
   if (exit_code == 0)
     result.status = base::TestResult::TEST_SUCCESS;
   else if (was_timeout)
     result.status = base::TestResult::TEST_TIMEOUT;
   else
     result.status = base::TestResult::TEST_FAILURE;
 
   result.elapsed_time = elapsed_time;
 
   // TODO(phajdan.jr): Use base::PrintTestOutputSnippetOnFailure after migrating
   // away from run_test_cases.py (http://crbug.com/236893).
   fprintf(stdout, "%s", output.c_str());
   fflush(stdout);
 
-  test_info.callback.Run(result);
+  for (size_t i = 0; i < test_info.callbacks.size(); i++)
+    test_info.callbacks[i].Run(result);
   parallel_launcher_.ResetOutputWatchdog();
 }
 
 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 (!base::StringToInt(switch_value, result) || *result < 1) {
@@ skipping 102 matching lines @@
 
   WrapperTestLauncherDelegate delegate(launcher_delegate, jobs);
   return base::LaunchTests(&delegate, argc, argv);
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 }  // namespace content