Add a MANUAL_ prefix for browser tests. These tests don't run unless --run-manual is specified.

content/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 23 matching lines @@
 #include "sandbox/win/src/dep.h"
 #include "sandbox/win/src/sandbox_factory.h"
 #include "sandbox/win/src/sandbox_types.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
 namespace test_launcher {
 
 namespace {
+
+// A multiplier for slow tests. We generally avoid multiplying
+// test timeouts by any constants. Here it is used as last resort
+// to implement the SLOW_ test prefix.
+static const int kSlowTestTimeoutMultiplier = 5;

[darin (slow to review), 2012/08/11 06:16:59]

nit: 'static' is redundant w/ anonymous namespace

[jam, 2012/08/13 00:45:25]

Done.

+
+// Tests with this prefix have a longer timeout, see above.
+const char kSlowTestPrefix[] = "SLOW_";
+
+// Tests with this prefix run before the same test without it, and use the same
+// profile. i.e. Foo.PRE_Test runs and then Foo.Test. This allows writing tests
+// that span browser restarts.
+const char kPreTestPrefix[] = "PRE_";
+
+// Manual tests only run when --run-manual is specified. This allows writing
+// tests that don't run automatically but are still in the same test binary.
+// This is useful so that a team that wants to run a few tests doesn't have to
+// add a new binary that must be compiled on all builds.
+const char kManualTestPrefix[] = "MANUAL_";
+
 TestLauncherDelegate* g_launcher_delegate;
 }
 
 // The environment variable name for the total number of test shards.
 const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
 // The environment variable name for the test shard index.
 const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
 
 // The default output file for XML output.
 const FilePath::CharType kDefaultOutputFile[] = FILE_PATH_LITERAL(
@@ skipping 220 matching lines @@
     // Returns if no more pattern can be found.
     if (cur_pattern == NULL) {
       return false;
     }
 
     // Skips the pattern separater (the ':' character).
     cur_pattern++;
   }
 }
 
-// A multiplier for slow tests. We generally avoid multiplying
-// test timeouts by any constants. Here it is used as last resort
-// to implement the SLOW_ test prefix.
-static const int kSlowTestTimeoutMultiplier = 5;
-
 base::TimeDelta GetTestTerminationTimeout(const std::string& test_name,
                                           base::TimeDelta default_timeout) {
   base::TimeDelta timeout = default_timeout;
 
   // Make it possible for selected tests to request a longer timeout.
   // Generally tests should really avoid doing too much, and splitting
   // a test instead of using SLOW prefix is strongly preferred.
-  if (test_name.find("SLOW_") != std::string::npos)
+  if (test_name.find(kSlowTestPrefix) != std::string::npos)
     timeout *= kSlowTestTimeoutMultiplier;
 
   return timeout;
 }
 
 int RunTestInternal(const testing::TestCase* test_case,
                     const std::string& test_name,
                     CommandLine* command_line,
                     base::TimeDelta default_timeout,
                     bool* was_timeout) {
   if (test_case) {
     std::string pre_test_name = test_name;
-    ReplaceFirstSubstringAfterOffset(&pre_test_name, 0, ".", ".PRE_");
+    std::string replace_string = std::string(".") + kPreTestPrefix;
+    ReplaceFirstSubstringAfterOffset(&pre_test_name, 0, ".", replace_string);
     for (int i = 0; i < test_case->total_test_count(); ++i) {
       const testing::TestInfo* test_info = test_case->GetTestInfo(i);
       std::string cur_test_name = test_info->test_case_name();
       cur_test_name.append(".");
       cur_test_name.append(test_info->name());
       if (cur_test_name == pre_test_name) {
         int exit_code = RunTestInternal(test_case, pre_test_name, command_line,
                                         default_timeout, was_timeout);
         if (exit_code != 0)
           return exit_code;
@@ skipping 156 matching lines @@
         continue;
 
       // Skip disabled tests.
       if (test_name.find("DISABLED") != std::string::npos &&
           !command_line->HasSwitch(kGTestRunDisabledTestsFlag)) {
         printer.OnTestEnd(test_info->name(), test_case->name(),
                           false, false, false, 0);
         continue;
       }
 
-      if (StartsWithASCII(test_info->name(), "PRE_", true))
+      if (StartsWithASCII(test_info->name(), kPreTestPrefix, true))
         continue;
 
+      if (StartsWithASCII(test_info->name(), kManualTestPrefix, true) &&
+          !command_line->HasSwitch(kRunManualTestsFlag)) {
+        continue;
+      }
+
       // Skip the test that doesn't match the filter string (if given).
       if ((!positive_filter.empty() &&
            !MatchesFilter(test_name, positive_filter)) ||
           MatchesFilter(test_name, negative_filter)) {
         printer.OnTestEnd(test_info->name(), test_case->name(),
                           false, false, false, 0);
         continue;
       }
 
       // Decide if this test should be run.
@@ skipping 89 matching lines @@
 
 const char kGTestFilterFlag[] = "gtest_filter";
 const char kGTestHelpFlag[]   = "gtest_help";
 const char kGTestListTestsFlag[] = "gtest_list_tests";
 const char kGTestRepeatFlag[] = "gtest_repeat";
 const char kGTestRunDisabledTestsFlag[] = "gtest_also_run_disabled_tests";
 const char kGTestOutputFlag[] = "gtest_output";
 
 const char kSingleProcessTestsFlag[]   = "single_process";
 const char kSingleProcessTestsAndChromeFlag[]   = "single-process";
+
+// See kManualTestPrefix above.
+const char kRunManualTestsFlag[] = "run-manual";
+
 // 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 kHelpFlag[]   = "help";
 
 const char kWarmupFlag[] = "warmup";
 
 TestLauncherDelegate::~TestLauncherDelegate() {
 }
@@ skipping 95 matching lines @@
       cycles--;
   }
   return exit_code;
 }
 
 TestLauncherDelegate* GetCurrentTestLauncherDelegate() {
   return g_launcher_delegate;
 }
 
 }  // namespace test_launcher