| // 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/launcher/unit_test_launcher.h" | |
| #include <map> | |
| #include <memory> | |
| #include <utility> | |
| #include "base/base_switches.h" | |
| #include "base/bind.h" | |
| #include "base/callback_helpers.h" | |
| #include "base/command_line.h" | |
| #include "base/compiler_specific.h" | |
| #include "base/debug/debugger.h" | |
| #include "base/files/file_util.h" | |
| #include "base/files/scoped_temp_dir.h" | |
| #include "base/format_macros.h" | |
| #include "base/location.h" | |
| #include "base/macros.h" | |
| #include "base/message_loop/message_loop.h" | |
| #include "base/sequence_checker.h" | |
| #include "base/single_thread_task_runner.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/launcher/test_launcher.h" | |
| #include "base/test/test_switches.h" | |
| #include "base/test/test_timeouts.h" | |
| #include "base/third_party/dynamic_annotations/dynamic_annotations.h" | |
| #include "base/threading/thread_checker.h" | |
| #include "base/threading/thread_task_runner_handle.h" | |
| #include "build/build_config.h" | |
| #include "testing/gtest/include/gtest/gtest.h" | |
| #if defined(OS_POSIX) | |
| #include "base/files/file_descriptor_watcher_posix.h" | |
| #endif | |
| namespace base { | |
| namespace { | |
| // This constant controls how many tests are run in a single batch by default. | |
| const size_t kDefaultTestBatchLimit = 10; | |
| const char kHelpFlag[] = "help"; | |
| // Flag to run all tests in a single process. | |
| const char kSingleProcessTestsFlag[] = "single-process-tests"; | |
| void PrintUsage() { | |
| fprintf(stdout, | |
| "Runs tests using the gtest framework, each batch of tests being\n" | |
| "run in their own process. Supported command-line flags:\n" | |
| "\n" | |
| " Common flags:\n" | |
| " --gtest_filter=...\n" | |
| " Runs a subset of tests (see --gtest_help for more info).\n" | |
| "\n" | |
| " --help\n" | |
| " Shows this message.\n" | |
| "\n" | |
| " --gtest_help\n" | |
| " Shows the gtest help message.\n" | |
| "\n" | |
| " --test-launcher-jobs=N\n" | |
| " Sets the number of parallel test jobs to N.\n" | |
| "\n" | |
| " --single-process-tests\n" | |
| " Runs the tests and the launcher in the same process. Useful\n" | |
| " for debugging a specific test in a debugger.\n" | |
| "\n" | |
| " Other flags:\n" | |
| " --test-launcher-filter-file=PATH\n" | |
| " Like --gtest_filter, but read the test filter from PATH.\n" | |
| " One pattern per line; lines starting with '-' are exclusions.\n" | |
| " See also //testing/buildbot/filters/README.md file.\n" | |
| "\n" | |
| " --test-launcher-batch-limit=N\n" | |
| " Sets the limit of test batch to run in a single process to N.\n" | |
| "\n" | |
| " --test-launcher-debug-launcher\n" | |
| " Disables autodetection of debuggers and similar tools,\n" | |
| " making it possible to use them to debug launcher itself.\n" | |
| "\n" | |
| " --test-launcher-retry-limit=N\n" | |
| " Sets the limit of test retries on failures to N.\n" | |
| "\n" | |
| " --test-launcher-summary-output=PATH\n" | |
| " Saves a JSON machine-readable summary of the run.\n" | |
| "\n" | |
| " --test-launcher-print-test-stdio=auto|always|never\n" | |
| " Controls when full test output is printed.\n" | |
| " auto means to print it when the test failed.\n" | |
| "\n" | |
| " --test-launcher-test-part-results-limit=N\n" | |
| " Sets the limit of failed EXPECT/ASSERT entries in the xml and\n" | |
| " JSON outputs per test to N (default N=10). Negative value \n" | |
| " will disable this limit.\n" | |
| "\n" | |
| " --test-launcher-total-shards=N\n" | |
| " Sets the total number of shards to N.\n" | |
| "\n" | |
| " --test-launcher-shard-index=N\n" | |
| " Sets the shard index to run to N (from 0 to TOTAL - 1).\n"); | |
| fflush(stdout); | |
| } | |
| class DefaultUnitTestPlatformDelegate : public UnitTestPlatformDelegate { | |
| public: | |
| DefaultUnitTestPlatformDelegate() = default; | |
| private: | |
| // UnitTestPlatformDelegate: | |
| bool GetTests(std::vector<TestIdentifier>* output) override { | |
| *output = GetCompiledInTests(); | |
| return true; | |
| } | |
| bool CreateResultsFile(base::FilePath* path) override { | |
| if (!CreateNewTempDirectory(FilePath::StringType(), path)) | |
| return false; | |
| *path = path->AppendASCII("test_results.xml"); | |
| return true; | |
| } | |
| bool CreateTemporaryFile(base::FilePath* path) override { | |
| if (!temp_dir_.IsValid() && !temp_dir_.CreateUniqueTempDir()) | |
| return false; | |
| return CreateTemporaryFileInDir(temp_dir_.GetPath(), path); | |
| } | |
| CommandLine GetCommandLineForChildGTestProcess( | |
| const std::vector<std::string>& test_names, | |
| const base::FilePath& output_file, | |
| const base::FilePath& flag_file) override { | |
| CommandLine new_cmd_line(*CommandLine::ForCurrentProcess()); | |
| CHECK(base::PathExists(flag_file)); | |
| std::string long_flags( | |
| std::string("--") + kGTestFilterFlag + "=" + | |
| JoinString(test_names, ":")); | |
| CHECK_EQ(static_cast<int>(long_flags.size()), | |
| WriteFile(flag_file, long_flags.data(), | |
| static_cast<int>(long_flags.size()))); | |
| new_cmd_line.AppendSwitchPath(switches::kTestLauncherOutput, output_file); | |
| new_cmd_line.AppendSwitchPath(kGTestFlagfileFlag, flag_file); | |
| new_cmd_line.AppendSwitch(kSingleProcessTestsFlag); | |
| return new_cmd_line; | |
| } | |
| std::string GetWrapperForChildGTestProcess() override { | |
| return std::string(); | |
| } | |
| void RelaunchTests(TestLauncher* test_launcher, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags) override { | |
| // Relaunch requested tests in parallel, but only use single | |
| // test per batch for more precise results (crashes, etc). | |
| for (const std::string& test_name : test_names) { | |
| std::vector<std::string> batch; | |
| batch.push_back(test_name); | |
| RunUnitTestsBatch(test_launcher, this, batch, launch_flags); | |
| } | |
| } | |
| ScopedTempDir temp_dir_; | |
| DISALLOW_COPY_AND_ASSIGN(DefaultUnitTestPlatformDelegate); | |
| }; | |
| 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 < 0) { | |
| LOG(ERROR) << "Invalid value for " << switch_name << ": " << switch_value; | |
| return false; | |
| } | |
| return true; | |
| } | |
| int LaunchUnitTestsInternal(RunTestSuiteCallback run_test_suite, | |
| size_t parallel_jobs, | |
| int default_batch_limit, | |
| bool use_job_objects, | |
| OnceClosure gtest_init) { | |
| #if defined(OS_ANDROID) | |
| // We can't easily fork on Android, just run the test suite directly. | |
| return std::move(run_test_suite).Run(); | |
| #else | |
| bool force_single_process = false; | |
| if (CommandLine::ForCurrentProcess()->HasSwitch( | |
| switches::kTestLauncherDebugLauncher)) { | |
| fprintf(stdout, "Forcing test launcher debugging mode.\n"); | |
| fflush(stdout); | |
| } else { | |
| if (base::debug::BeingDebugged()) { | |
| fprintf(stdout, | |
| "Debugger detected, switching to single process mode.\n" | |
| "Pass --test-launcher-debug-launcher to debug the launcher " | |
| "itself.\n"); | |
| fflush(stdout); | |
| force_single_process = true; | |
| } | |
| } | |
| if (CommandLine::ForCurrentProcess()->HasSwitch(kGTestHelpFlag) || | |
| CommandLine::ForCurrentProcess()->HasSwitch(kGTestListTestsFlag) || | |
| CommandLine::ForCurrentProcess()->HasSwitch(kSingleProcessTestsFlag) || | |
| CommandLine::ForCurrentProcess()->HasSwitch( | |
| switches::kTestChildProcess) || | |
| force_single_process) { | |
| return std::move(run_test_suite).Run(); | |
| } | |
| #endif | |
| if (CommandLine::ForCurrentProcess()->HasSwitch(kHelpFlag)) { | |
| PrintUsage(); | |
| return 0; | |
| } | |
| TimeTicks start_time(TimeTicks::Now()); | |
| std::move(gtest_init).Run(); | |
| TestTimeouts::Initialize(); | |
| int batch_limit = default_batch_limit; | |
| if (!GetSwitchValueAsInt(switches::kTestLauncherBatchLimit, &batch_limit)) | |
| return 1; | |
| fprintf(stdout, | |
| "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"); | |
| fflush(stdout); | |
| MessageLoopForIO message_loop; | |
| #if defined(OS_POSIX) | |
| FileDescriptorWatcher file_descriptor_watcher(&message_loop); | |
| #endif | |
| DefaultUnitTestPlatformDelegate platform_delegate; | |
| UnitTestLauncherDelegate delegate( | |
| &platform_delegate, batch_limit, use_job_objects); | |
| TestLauncher launcher(&delegate, parallel_jobs); | |
| bool success = launcher.Run(); | |
| fprintf(stdout, "Tests took %" PRId64 " seconds.\n", | |
| (TimeTicks::Now() - start_time).InSeconds()); | |
| fflush(stdout); | |
| return (success ? 0 : 1); | |
| } | |
| void InitGoogleTestChar(int* argc, char** argv) { | |
| testing::InitGoogleTest(argc, argv); | |
| } | |
| #if defined(OS_WIN) | |
| void InitGoogleTestWChar(int* argc, wchar_t** argv) { | |
| testing::InitGoogleTest(argc, argv); | |
| } | |
| #endif // defined(OS_WIN) | |
| // Interprets test results and reports to the test launcher. Returns true | |
| // on success. | |
| bool ProcessTestResults( | |
| TestLauncher* test_launcher, | |
| const std::vector<std::string>& test_names, | |
| const base::FilePath& output_file, | |
| const std::string& output, | |
| int exit_code, | |
| bool was_timeout, | |
| std::vector<std::string>* tests_to_relaunch) { | |
| std::vector<TestResult> test_results; | |
| bool crashed = false; | |
| bool have_test_results = | |
| ProcessGTestOutput(output_file, &test_results, &crashed); | |
| bool called_any_callback = false; | |
| if (have_test_results) { | |
| // TODO(phajdan.jr): Check for duplicates and mismatches between | |
| // the results we got from XML file and tests we intended to run. | |
| std::map<std::string, TestResult> results_map; | |
| for (size_t i = 0; i < test_results.size(); i++) | |
| results_map[test_results[i].full_name] = test_results[i]; | |
| bool had_interrupted_test = false; | |
| // Results to be reported back to the test launcher. | |
| std::vector<TestResult> final_results; | |
| for (size_t i = 0; i < test_names.size(); i++) { | |
| if (ContainsKey(results_map, test_names[i])) { | |
| TestResult test_result = results_map[test_names[i]]; | |
| if (test_result.status == TestResult::TEST_CRASH) { | |
| had_interrupted_test = true; | |
| if (was_timeout) { | |
| // Fix up the test status: we forcibly kill the child process | |
| // after the timeout, so from XML results it looks just like | |
| // a crash. | |
| test_result.status = TestResult::TEST_TIMEOUT; | |
| } | |
| } else if (test_result.status == TestResult::TEST_SUCCESS || | |
| test_result.status == TestResult::TEST_FAILURE) { | |
| // We run multiple tests in a batch with a timeout applied | |
| // to the entire batch. It is possible that with other tests | |
| // running quickly some tests take longer than the per-test timeout. | |
| // For consistent handling of tests independent of order and other | |
| // factors, mark them as timing out. | |
| if (test_result.elapsed_time > | |
| TestTimeouts::test_launcher_timeout()) { | |
| test_result.status = TestResult::TEST_TIMEOUT; | |
| } | |
| } | |
| test_result.output_snippet = GetTestOutputSnippet(test_result, output); | |
| final_results.push_back(test_result); | |
| } else if (had_interrupted_test) { | |
| tests_to_relaunch->push_back(test_names[i]); | |
| } else { | |
| // TODO(phajdan.jr): Explicitly pass the info that the test didn't | |
| // run for a mysterious reason. | |
| LOG(ERROR) << "no test result for " << test_names[i]; | |
| TestResult test_result; | |
| test_result.full_name = test_names[i]; | |
| test_result.status = TestResult::TEST_UNKNOWN; | |
| test_result.output_snippet = GetTestOutputSnippet(test_result, output); | |
| final_results.push_back(test_result); | |
| } | |
| } | |
| // TODO(phajdan.jr): Handle the case where processing XML output | |
| // indicates a crash but none of the test results is marked as crashing. | |
| if (final_results.empty()) | |
| return false; | |
| bool has_non_success_test = false; | |
| for (size_t i = 0; i < final_results.size(); i++) { | |
| if (final_results[i].status != TestResult::TEST_SUCCESS) { | |
| has_non_success_test = true; | |
| break; | |
| } | |
| } | |
| if (!has_non_success_test && exit_code != 0) { | |
| // This is a bit surprising case: all tests are marked as successful, | |
| // but the exit code was not zero. This can happen e.g. under memory | |
| // tools that report leaks this way. Mark all tests as a failure on exit, | |
| // and for more precise info they'd need to be retried serially. | |
| for (size_t i = 0; i < final_results.size(); i++) | |
| final_results[i].status = TestResult::TEST_FAILURE_ON_EXIT; | |
| } | |
| for (size_t i = 0; i < final_results.size(); i++) { | |
| // Fix the output snippet after possible changes to the test result. | |
| final_results[i].output_snippet = | |
| GetTestOutputSnippet(final_results[i], output); | |
| test_launcher->OnTestFinished(final_results[i]); | |
| called_any_callback = true; | |
| } | |
| } else { | |
| fprintf(stdout, | |
| "Failed to get out-of-band test success data, " | |
| "dumping full stdio below:\n%s\n", | |
| output.c_str()); | |
| fflush(stdout); | |
| // We do not have reliable details about test results (parsing test | |
| // stdout is known to be unreliable). | |
| if (test_names.size() == 1) { | |
| // There is only one test. Try to determine status by exit code. | |
| const std::string& test_name = test_names.front(); | |
| TestResult test_result; | |
| test_result.full_name = test_name; | |
| if (was_timeout) { | |
| test_result.status = TestResult::TEST_TIMEOUT; | |
| } else if (exit_code != 0) { | |
| test_result.status = TestResult::TEST_FAILURE; | |
| } else { | |
| // It's strange case when test executed successfully, | |
| // but we failed to read machine-readable report for it. | |
| test_result.status = TestResult::TEST_UNKNOWN; | |
| } | |
| test_launcher->OnTestFinished(test_result); | |
| called_any_callback = true; | |
| } else { | |
| // There is more than one test. Retry them individually. | |
| for (const std::string& test_name : test_names) | |
| tests_to_relaunch->push_back(test_name); | |
| } | |
| } | |
| return called_any_callback; | |
| } | |
| class UnitTestProcessLifetimeObserver : public ProcessLifetimeObserver { | |
| public: | |
| ~UnitTestProcessLifetimeObserver() override { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| } | |
| TestLauncher* test_launcher() { return test_launcher_; } | |
| UnitTestPlatformDelegate* platform_delegate() { return platform_delegate_; } | |
| const std::vector<std::string>& test_names() { return test_names_; } | |
| int launch_flags() { return launch_flags_; } | |
| const FilePath& output_file() { return output_file_; } | |
| const FilePath& flag_file() { return flag_file_; } | |
| protected: | |
| UnitTestProcessLifetimeObserver(TestLauncher* test_launcher, | |
| UnitTestPlatformDelegate* platform_delegate, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags, | |
| const FilePath& output_file, | |
| const FilePath& flag_file) | |
| : ProcessLifetimeObserver(), | |
| test_launcher_(test_launcher), | |
| platform_delegate_(platform_delegate), | |
| test_names_(test_names), | |
| launch_flags_(launch_flags), | |
| output_file_(output_file), | |
| flag_file_(flag_file) {} | |
| SEQUENCE_CHECKER(sequence_checker_); | |
| private: | |
| TestLauncher* const test_launcher_; | |
| UnitTestPlatformDelegate* const platform_delegate_; | |
| const std::vector<std::string> test_names_; | |
| const int launch_flags_; | |
| const FilePath output_file_; | |
| const FilePath flag_file_; | |
| DISALLOW_COPY_AND_ASSIGN(UnitTestProcessLifetimeObserver); | |
| }; | |
| class ParallelUnitTestProcessLifetimeObserver | |
| : public UnitTestProcessLifetimeObserver { | |
| public: | |
| ParallelUnitTestProcessLifetimeObserver( | |
| TestLauncher* test_launcher, | |
| UnitTestPlatformDelegate* platform_delegate, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags, | |
| const FilePath& output_file, | |
| const FilePath& flag_file) | |
| : UnitTestProcessLifetimeObserver(test_launcher, | |
| platform_delegate, | |
| test_names, | |
| launch_flags, | |
| output_file, | |
| flag_file) {} | |
| ~ParallelUnitTestProcessLifetimeObserver() override = default; | |
| private: | |
| // ProcessLifetimeObserver: | |
| void OnCompleted(int exit_code, | |
| TimeDelta elapsed_time, | |
| bool was_timeout, | |
| const std::string& output) override; | |
| DISALLOW_COPY_AND_ASSIGN(ParallelUnitTestProcessLifetimeObserver); | |
| }; | |
| void ParallelUnitTestProcessLifetimeObserver::OnCompleted( | |
| int exit_code, | |
| TimeDelta elapsed_time, | |
| bool was_timeout, | |
| const std::string& output) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| std::vector<std::string> tests_to_relaunch; | |
| ProcessTestResults(test_launcher(), test_names(), output_file(), output, | |
| exit_code, was_timeout, &tests_to_relaunch); | |
| if (!tests_to_relaunch.empty()) { | |
| platform_delegate()->RelaunchTests(test_launcher(), tests_to_relaunch, | |
| launch_flags()); | |
| } | |
| // The temporary file's directory is also temporary. | |
| DeleteFile(output_file().DirName(), true); | |
| if (!flag_file().empty()) | |
| DeleteFile(flag_file(), false); | |
| } | |
| class SerialUnitTestProcessLifetimeObserver | |
| : public UnitTestProcessLifetimeObserver { | |
| public: | |
| SerialUnitTestProcessLifetimeObserver( | |
| TestLauncher* test_launcher, | |
| UnitTestPlatformDelegate* platform_delegate, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags, | |
| const FilePath& output_file, | |
| const FilePath& flag_file, | |
| std::vector<std::string>&& next_test_names) | |
| : UnitTestProcessLifetimeObserver(test_launcher, | |
| platform_delegate, | |
| test_names, | |
| launch_flags, | |
| output_file, | |
| flag_file), | |
| next_test_names_(std::move(next_test_names)) {} | |
| ~SerialUnitTestProcessLifetimeObserver() override = default; | |
| private: | |
| // ProcessLifetimeObserver: | |
| void OnCompleted(int exit_code, | |
| TimeDelta elapsed_time, | |
| bool was_timeout, | |
| const std::string& output) override; | |
| std::vector<std::string> next_test_names_; | |
| DISALLOW_COPY_AND_ASSIGN(SerialUnitTestProcessLifetimeObserver); | |
| }; | |
| void SerialUnitTestProcessLifetimeObserver::OnCompleted( | |
| int exit_code, | |
| TimeDelta elapsed_time, | |
| bool was_timeout, | |
| const std::string& output) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| std::vector<std::string> tests_to_relaunch; | |
| bool called_any_callbacks = | |
| ProcessTestResults(test_launcher(), test_names(), output_file(), output, | |
| exit_code, was_timeout, &tests_to_relaunch); | |
| // There is only one test, there cannot be other tests to relaunch | |
| // due to a crash. | |
| DCHECK(tests_to_relaunch.empty()); | |
| // There is only one test, we should have called back with its result. | |
| DCHECK(called_any_callbacks); | |
| // The temporary file's directory is also temporary. | |
| DeleteFile(output_file().DirName(), true); | |
| if (!flag_file().empty()) | |
| DeleteFile(flag_file(), false); | |
| ThreadTaskRunnerHandle::Get()->PostTask( | |
| FROM_HERE, | |
| BindOnce(&RunUnitTestsSerially, test_launcher(), platform_delegate(), | |
| std::move(next_test_names_), launch_flags())); | |
| } | |
| } // namespace | |
| int LaunchUnitTests(int argc, | |
| char** argv, | |
| RunTestSuiteCallback run_test_suite) { | |
| CommandLine::Init(argc, argv); | |
| size_t parallel_jobs = NumParallelJobs(); | |
| if (parallel_jobs == 0U) { | |
| return 1; | |
| } | |
| return LaunchUnitTestsInternal(std::move(run_test_suite), parallel_jobs, | |
| kDefaultTestBatchLimit, true, | |
| BindOnce(&InitGoogleTestChar, &argc, argv)); | |
| } | |
| int LaunchUnitTestsSerially(int argc, | |
| char** argv, | |
| RunTestSuiteCallback run_test_suite) { | |
| CommandLine::Init(argc, argv); | |
| return LaunchUnitTestsInternal(std::move(run_test_suite), 1U, | |
| kDefaultTestBatchLimit, true, | |
| BindOnce(&InitGoogleTestChar, &argc, argv)); | |
| } | |
| int LaunchUnitTestsWithOptions(int argc, | |
| char** argv, | |
| size_t parallel_jobs, | |
| int default_batch_limit, | |
| bool use_job_objects, | |
| RunTestSuiteCallback run_test_suite) { | |
| CommandLine::Init(argc, argv); | |
| return LaunchUnitTestsInternal(std::move(run_test_suite), parallel_jobs, | |
| default_batch_limit, use_job_objects, | |
| BindOnce(&InitGoogleTestChar, &argc, argv)); | |
| } | |
| #if defined(OS_WIN) | |
| int LaunchUnitTests(int argc, | |
| wchar_t** argv, | |
| bool use_job_objects, | |
| RunTestSuiteCallback run_test_suite) { | |
| // Windows CommandLine::Init ignores argv anyway. | |
| CommandLine::Init(argc, NULL); | |
| size_t parallel_jobs = NumParallelJobs(); | |
| if (parallel_jobs == 0U) { | |
| return 1; | |
| } | |
| return LaunchUnitTestsInternal(std::move(run_test_suite), parallel_jobs, | |
| kDefaultTestBatchLimit, use_job_objects, | |
| BindOnce(&InitGoogleTestWChar, &argc, argv)); | |
| } | |
| #endif // defined(OS_WIN) | |
| void RunUnitTestsSerially( | |
| TestLauncher* test_launcher, | |
| UnitTestPlatformDelegate* platform_delegate, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags) { | |
| if (test_names.empty()) | |
| return; | |
| // Create a dedicated temporary directory to store the xml result data | |
| // per run to ensure clean state and make it possible to launch multiple | |
| // processes in parallel. | |
| FilePath output_file; | |
| CHECK(platform_delegate->CreateResultsFile(&output_file)); | |
| FilePath flag_file; | |
| platform_delegate->CreateTemporaryFile(&flag_file); | |
| auto observer = std::make_unique<SerialUnitTestProcessLifetimeObserver>( | |
| test_launcher, platform_delegate, | |
| std::vector<std::string>(1, test_names.back()), launch_flags, output_file, | |
| flag_file, | |
| std::vector<std::string>(test_names.begin(), test_names.end() - 1)); | |
| CommandLine cmd_line(platform_delegate->GetCommandLineForChildGTestProcess( | |
| observer->test_names(), output_file, flag_file)); | |
| TestLauncher::LaunchOptions launch_options; | |
| launch_options.flags = launch_flags; | |
| test_launcher->LaunchChildGTestProcess( | |
| cmd_line, platform_delegate->GetWrapperForChildGTestProcess(), | |
| TestTimeouts::test_launcher_timeout(), launch_options, | |
| std::move(observer)); | |
| } | |
| void RunUnitTestsBatch( | |
| TestLauncher* test_launcher, | |
| UnitTestPlatformDelegate* platform_delegate, | |
| const std::vector<std::string>& test_names, | |
| int launch_flags) { | |
| if (test_names.empty()) | |
| return; | |
| // Create a dedicated temporary directory to store the xml result data | |
| // per run to ensure clean state and make it possible to launch multiple | |
| // processes in parallel. | |
| FilePath output_file; | |
| CHECK(platform_delegate->CreateResultsFile(&output_file)); | |
| FilePath flag_file; | |
| platform_delegate->CreateTemporaryFile(&flag_file); | |
| auto observer = std::make_unique<ParallelUnitTestProcessLifetimeObserver>( | |
| test_launcher, platform_delegate, test_names, launch_flags, output_file, | |
| flag_file); | |
| CommandLine cmd_line(platform_delegate->GetCommandLineForChildGTestProcess( | |
| test_names, output_file, flag_file)); | |
| // Adjust the timeout depending on how many tests we're running | |
| // (note that e.g. the last batch of tests will be smaller). | |
| // TODO(phajdan.jr): Consider an adaptive timeout, which can change | |
| // depending on how many tests ran and how many remain. | |
| // Note: do NOT parse child's stdout to do that, it's known to be | |
| // unreliable (e.g. buffering issues can mix up the output). | |
| TimeDelta timeout = test_names.size() * TestTimeouts::test_launcher_timeout(); | |
| TestLauncher::LaunchOptions options; | |
| options.flags = launch_flags; | |
| test_launcher->LaunchChildGTestProcess( | |
| cmd_line, platform_delegate->GetWrapperForChildGTestProcess(), timeout, | |
| options, std::move(observer)); | |
| } | |
| UnitTestLauncherDelegate::UnitTestLauncherDelegate( | |
| UnitTestPlatformDelegate* platform_delegate, | |
| size_t batch_limit, | |
| bool use_job_objects) | |
| : platform_delegate_(platform_delegate), | |
| batch_limit_(batch_limit), | |
| use_job_objects_(use_job_objects) { | |
| } | |
| UnitTestLauncherDelegate::~UnitTestLauncherDelegate() { | |
| DCHECK(thread_checker_.CalledOnValidThread()); | |
| } | |
| bool UnitTestLauncherDelegate::GetTests(std::vector<TestIdentifier>* output) { | |
| DCHECK(thread_checker_.CalledOnValidThread()); | |
| return platform_delegate_->GetTests(output); | |
| } | |
| bool UnitTestLauncherDelegate::ShouldRunTest(const std::string& test_case_name, | |
| const std::string& test_name) { | |
| DCHECK(thread_checker_.CalledOnValidThread()); | |
| // There is no additional logic to disable specific tests. | |
| return true; | |
| } | |
| size_t UnitTestLauncherDelegate::RunTests( | |
| TestLauncher* test_launcher, | |
| const std::vector<std::string>& test_names) { | |
| DCHECK(thread_checker_.CalledOnValidThread()); | |
| int launch_flags = use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0; | |
| std::vector<std::string> batch; | |
| for (size_t i = 0; i < test_names.size(); i++) { | |
| batch.push_back(test_names[i]); | |
| // Use 0 to indicate unlimited batch size. | |
| if (batch.size() >= batch_limit_ && batch_limit_ != 0) { | |
| RunUnitTestsBatch(test_launcher, platform_delegate_, batch, launch_flags); | |
| batch.clear(); | |
| } | |
| } | |
| RunUnitTestsBatch(test_launcher, platform_delegate_, batch, launch_flags); | |
| return test_names.size(); | |
| } | |
| size_t UnitTestLauncherDelegate::RetryTests( | |
| TestLauncher* test_launcher, | |
| const std::vector<std::string>& test_names) { | |
| ThreadTaskRunnerHandle::Get()->PostTask( | |
| FROM_HERE, | |
| BindOnce(&RunUnitTestsSerially, test_launcher, platform_delegate_, | |
| test_names, | |
| use_job_objects_ ? TestLauncher::USE_JOB_OBJECTS : 0)); | |
| return test_names.size(); | |
| } | |
| } // namespace base |