| OLD | NEW |
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #ifndef BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_ | |
| 6 #define BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_ | |
| 7 | |
| 8 #include <set> | |
| 9 #include <string> | |
| 10 | |
| 11 #include "base/basictypes.h" | |
| 12 #include "base/callback_forward.h" | |
| 13 #include "base/compiler_specific.h" | |
| 14 #include "base/test/gtest_util.h" | |
| 15 #include "base/test/launcher/test_result.h" | |
| 16 #include "base/test/launcher/test_results_tracker.h" | |
| 17 #include "base/time/time.h" | |
| 18 #include "base/timer/timer.h" | |
| 19 | |
| 20 namespace testing { | |
| 21 class TestCase; | |
| 22 class TestInfo; | |
| 23 } | |
| 24 | |
| 25 namespace base { | |
| 26 | |
| 27 class CommandLine; | |
| 28 struct LaunchOptions; | |
| 29 class SequencedWorkerPoolOwner; | |
| 30 class TestLauncher; | |
| 31 | |
| 32 // Constants for GTest command-line flags. | |
| 33 extern const char kGTestFilterFlag[]; | |
| 34 extern const char kGTestHelpFlag[]; | |
| 35 extern const char kGTestListTestsFlag[]; | |
| 36 extern const char kGTestRepeatFlag[]; | |
| 37 extern const char kGTestRunDisabledTestsFlag[]; | |
| 38 extern const char kGTestOutputFlag[]; | |
| 39 | |
| 40 // Interface for use with LaunchTests that abstracts away exact details | |
| 41 // which tests and how are run. | |
| 42 class TestLauncherDelegate { | |
| 43 public: | |
| 44 // Called to get names of tests available for running. The delegate | |
| 45 // must put the result in |output| and return true on success. | |
| 46 virtual bool GetTests(std::vector<SplitTestName>* output) = 0; | |
| 47 | |
| 48 // Called before a test is considered for running. If it returns false, | |
| 49 // the test is not run. If it returns true, the test will be run provided | |
| 50 // it is part of the current shard. | |
| 51 virtual bool ShouldRunTest(const std::string& test_case_name, | |
| 52 const std::string& test_name) = 0; | |
| 53 | |
| 54 // Called to make the delegate run the specified tests. The delegate must | |
| 55 // return the number of actual tests it's going to run (can be smaller, | |
| 56 // equal to, or larger than size of |test_names|). It must also call | |
| 57 // |test_launcher|'s OnTestFinished method once per every run test, | |
| 58 // regardless of its success. | |
| 59 virtual size_t RunTests(TestLauncher* test_launcher, | |
| 60 const std::vector<std::string>& test_names) = 0; | |
| 61 | |
| 62 // Called to make the delegate retry the specified tests. The delegate must | |
| 63 // return the number of actual tests it's going to retry (can be smaller, | |
| 64 // equal to, or larger than size of |test_names|). It must also call | |
| 65 // |test_launcher|'s OnTestFinished method once per every retried test, | |
| 66 // regardless of its success. | |
| 67 virtual size_t RetryTests(TestLauncher* test_launcher, | |
| 68 const std::vector<std::string>& test_names) = 0; | |
| 69 | |
| 70 protected: | |
| 71 virtual ~TestLauncherDelegate(); | |
| 72 }; | |
| 73 | |
| 74 // Launches tests using a TestLauncherDelegate. | |
| 75 class TestLauncher { | |
| 76 public: | |
| 77 // Flags controlling behavior of LaunchChildGTestProcess. | |
| 78 enum LaunchChildGTestProcessFlags { | |
| 79 // Allows usage of job objects on Windows. Helps properly clean up child | |
| 80 // processes. | |
| 81 USE_JOB_OBJECTS = (1 << 0), | |
| 82 | |
| 83 // Allows breakaway from job on Windows. May result in some child processes | |
| 84 // not being properly terminated after launcher dies if these processes | |
| 85 // fail to cooperate. | |
| 86 ALLOW_BREAKAWAY_FROM_JOB = (1 << 1), | |
| 87 }; | |
| 88 | |
| 89 // Constructor. |parallel_jobs| is the limit of simultaneous parallel test | |
| 90 // jobs. | |
| 91 TestLauncher(TestLauncherDelegate* launcher_delegate, size_t parallel_jobs); | |
| 92 ~TestLauncher(); | |
| 93 | |
| 94 // Runs the launcher. Must be called at most once. | |
| 95 bool Run() WARN_UNUSED_RESULT; | |
| 96 | |
| 97 // Callback called after a child process finishes. First argument is the exit | |
| 98 // code, second one is child process elapsed time, third one is true if | |
| 99 // the child process was terminated because of a timeout, and fourth one | |
| 100 // contains output of the child (stdout and stderr together). | |
| 101 typedef Callback<void(int, const TimeDelta&, bool, const std::string&)> | |
| 102 LaunchChildGTestProcessCallback; | |
| 103 | |
| 104 // Launches a child process (assumed to be gtest-based binary) using | |
| 105 // |command_line|. If |wrapper| is not empty, it is prepended to the final | |
| 106 // command line. If the child process is still running after |timeout|, it | |
| 107 // is terminated. After the child process finishes |callback| is called | |
| 108 // on the same thread this method was called. | |
| 109 void LaunchChildGTestProcess(const CommandLine& command_line, | |
| 110 const std::string& wrapper, | |
| 111 base::TimeDelta timeout, | |
| 112 int flags, | |
| 113 const LaunchChildGTestProcessCallback& callback); | |
| 114 | |
| 115 // Called when a test has finished running. | |
| 116 void OnTestFinished(const TestResult& result); | |
| 117 | |
| 118 private: | |
| 119 bool Init() WARN_UNUSED_RESULT; | |
| 120 | |
| 121 // Runs all tests in current iteration. Uses callbacks to communicate success. | |
| 122 void RunTests(); | |
| 123 | |
| 124 void RunTestIteration(); | |
| 125 | |
| 126 // Saves test results summary as JSON if requested from command line. | |
| 127 void MaybeSaveSummaryAsJSON(); | |
| 128 | |
| 129 // Called on a worker thread after a child process finishes. | |
| 130 void OnLaunchTestProcessFinished( | |
| 131 const LaunchChildGTestProcessCallback& callback, | |
| 132 int exit_code, | |
| 133 const TimeDelta& elapsed_time, | |
| 134 bool was_timeout, | |
| 135 const std::string& output); | |
| 136 | |
| 137 // Called when a test iteration is finished. | |
| 138 void OnTestIterationFinished(); | |
| 139 | |
| 140 // Called by the delay timer when no output was made for a while. | |
| 141 void OnOutputTimeout(); | |
| 142 | |
| 143 // Make sure we don't accidentally call the wrong methods e.g. on the worker | |
| 144 // pool thread. With lots of callbacks used this is non-trivial. | |
| 145 // Should be the first member so that it's destroyed last: when destroying | |
| 146 // other members, especially the worker pool, we may check the code is running | |
| 147 // on the correct thread. | |
| 148 ThreadChecker thread_checker_; | |
| 149 | |
| 150 TestLauncherDelegate* launcher_delegate_; | |
| 151 | |
| 152 // Support for outer sharding, just like gtest does. | |
| 153 int32 total_shards_; // Total number of outer shards, at least one. | |
| 154 int32 shard_index_; // Index of shard the launcher is to run. | |
| 155 | |
| 156 int cycles_; // Number of remaining test itreations, or -1 for infinite. | |
| 157 | |
| 158 // Test filters (empty means no filter). | |
| 159 std::vector<std::string> positive_test_filter_; | |
| 160 std::vector<std::string> negative_test_filter_; | |
| 161 | |
| 162 // Tests to use (cached result of TestLauncherDelegate::GetTests). | |
| 163 std::vector<SplitTestName> tests_; | |
| 164 | |
| 165 // Number of tests started in this iteration. | |
| 166 size_t test_started_count_; | |
| 167 | |
| 168 // Number of tests finished in this iteration. | |
| 169 size_t test_finished_count_; | |
| 170 | |
| 171 // Number of tests successfully finished in this iteration. | |
| 172 size_t test_success_count_; | |
| 173 | |
| 174 // Number of tests either timing out or having an unknown result, | |
| 175 // likely indicating a more systemic problem if widespread. | |
| 176 size_t test_broken_count_; | |
| 177 | |
| 178 // Number of retries in this iteration. | |
| 179 size_t retry_count_; | |
| 180 | |
| 181 // Maximum number of retries per iteration. | |
| 182 size_t retry_limit_; | |
| 183 | |
| 184 // Tests to retry in this iteration. | |
| 185 std::set<std::string> tests_to_retry_; | |
| 186 | |
| 187 // Result to be returned from Run. | |
| 188 bool run_result_; | |
| 189 | |
| 190 TestResultsTracker results_tracker_; | |
| 191 | |
| 192 // Watchdog timer to make sure we do not go without output for too long. | |
| 193 DelayTimer<TestLauncher> watchdog_timer_; | |
| 194 | |
| 195 // Number of jobs to run in parallel. | |
| 196 size_t parallel_jobs_; | |
| 197 | |
| 198 // Worker pool used to launch processes in parallel. | |
| 199 scoped_ptr<SequencedWorkerPoolOwner> worker_pool_owner_; | |
| 200 | |
| 201 DISALLOW_COPY_AND_ASSIGN(TestLauncher); | |
| 202 }; | |
| 203 | |
| 204 // Extract part from |full_output| that applies to |result|. | |
| 205 std::string GetTestOutputSnippet(const TestResult& result, | |
| 206 const std::string& full_output); | |
| 207 | |
| 208 } // namespace base | |
| 209 | |
| 210 #endif // BASE_TEST_LAUNCHER_TEST_LAUNCHER_H_ | |
| OLD | NEW |