| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/test/test_suite.h" |
| |
| #include <signal.h> |
| |
| #include <algorithm> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "base/allocator/partition_allocator/partition_alloc_buildflags.h" |
| #include "base/allocator/partition_allocator/tagging.h" |
| #include "base/at_exit.h" |
| #include "base/base_paths.h" |
| #include "base/base_switches.h" |
| #include "base/command_line.h" |
| #include "base/debug/asan_service.h" |
| #include "base/debug/debugger.h" |
| #include "base/debug/profiler.h" |
| #include "base/debug/stack_trace.h" |
| #include "base/feature_list.h" |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/functional/bind.h" |
| #include "base/i18n/icu_util.h" |
| #include "base/i18n/rtl.h" |
| #include "base/logging.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/no_destructor.h" |
| #include "base/path_service.h" |
| #include "base/process/launch.h" |
| #include "base/process/memory.h" |
| #include "base/process/process.h" |
| #include "base/process/process_handle.h" |
| #include "base/strings/string_piece.h" |
| #include "base/strings/utf_string_conversions.h" |
| #include "base/task/thread_pool/thread_pool_instance.h" |
| #include "base/test/gtest_xml_unittest_result_printer.h" |
| #include "base/test/gtest_xml_util.h" |
| #include "base/test/icu_test_util.h" |
| #include "base/test/launcher/unit_test_launcher.h" |
| #include "base/test/mock_entropy_provider.h" |
| #include "base/test/multiprocess_test.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/scoped_run_loop_timeout.h" |
| #include "base/test/test_switches.h" |
| #include "base/test/test_timeouts.h" |
| #include "base/threading/platform_thread.h" |
| #include "base/time/time.h" |
| #include "base/tracing_buildflags.h" |
| #include "build/build_config.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/multiprocess_func_list.h" |
| |
| #if BUILDFLAG(IS_APPLE) |
| #include "base/mac/scoped_nsautorelease_pool.h" |
| #endif // BUILDFLAG(IS_APPLE) |
| |
| #if BUILDFLAG(IS_IOS) |
| #include "base/test/test_listener_ios.h" |
| #include "base/test/test_support_ios.h" |
| #else |
| #include "base/strings/string_util.h" |
| #include "third_party/icu/source/common/unicode/uloc.h" |
| #endif |
| |
| #if BUILDFLAG(IS_ANDROID) |
| #include "base/test/test_support_android.h" |
| #endif |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| #include "third_party/test_fonts/fontconfig/fontconfig_util_linux.h" |
| #endif |
| |
| #if BUILDFLAG(IS_FUCHSIA) |
| #include "base/fuchsia/system_info.h" |
| #endif |
| |
| #if BUILDFLAG(IS_WIN) |
| #if defined(_DEBUG) |
| #include <crtdbg.h> |
| #endif // _DEBUG |
| #include <windows.h> |
| |
| #include "base/debug/handle_hooks_win.h" |
| #endif // BUILDFLAG(IS_WIN) |
| |
| #if BUILDFLAG(USE_PARTITION_ALLOC) |
| #include "base/allocator/partition_alloc_support.h" |
| #endif // BUILDFLAG(USE_PARTITION_ALLOC) |
| |
| namespace base { |
| |
| namespace { |
| |
| // Returns true if the test is marked as "MAYBE_". |
| // When using different prefixes depending on platform, we use MAYBE_ and |
| // preprocessor directives to replace MAYBE_ with the target prefix. |
| bool IsMarkedMaybe(const testing::TestInfo& test) { |
| return strncmp(test.name(), "MAYBE_", 6) == 0; |
| } |
| |
| class DisableMaybeTests : public testing::EmptyTestEventListener { |
| public: |
| void OnTestStart(const testing::TestInfo& test_info) override { |
| ASSERT_FALSE(IsMarkedMaybe(test_info)) |
| << "Probably the OS #ifdefs don't include all of the necessary " |
| "platforms.\nPlease ensure that no tests have the MAYBE_ prefix " |
| "after the code is preprocessed."; |
| } |
| }; |
| |
| class ResetCommandLineBetweenTests : public testing::EmptyTestEventListener { |
| public: |
| ResetCommandLineBetweenTests() : old_command_line_(CommandLine::NO_PROGRAM) {} |
| |
| ResetCommandLineBetweenTests(const ResetCommandLineBetweenTests&) = delete; |
| ResetCommandLineBetweenTests& operator=(const ResetCommandLineBetweenTests&) = |
| delete; |
| |
| void OnTestStart(const testing::TestInfo& test_info) override { |
| old_command_line_ = *CommandLine::ForCurrentProcess(); |
| } |
| |
| void OnTestEnd(const testing::TestInfo& test_info) override { |
| *CommandLine::ForCurrentProcess() = old_command_line_; |
| } |
| |
| private: |
| CommandLine old_command_line_; |
| }; |
| |
| // Initializes a base::test::ScopedFeatureList for each individual test, which |
| // involves a FeatureList and a FieldTrialList, such that unit test don't need |
| // to initialize them manually. |
| class FeatureListScopedToEachTest : public testing::EmptyTestEventListener { |
| public: |
| FeatureListScopedToEachTest() = default; |
| ~FeatureListScopedToEachTest() override = default; |
| |
| FeatureListScopedToEachTest(const FeatureListScopedToEachTest&) = delete; |
| FeatureListScopedToEachTest& operator=(const FeatureListScopedToEachTest&) = |
| delete; |
| |
| void OnTestStart(const testing::TestInfo& test_info) override { |
| const CommandLine* command_line = CommandLine::ForCurrentProcess(); |
| |
| // We set up a FeatureList via ScopedFeatureList::InitFromCommandLine(). |
| // This ensures that code using that API will not hit an error that it's |
| // not set. It will be cleared by ~ScopedFeatureList(). |
| |
| // TestFeatureForBrowserTest1 and TestFeatureForBrowserTest2 used in |
| // ContentBrowserTestScopedFeatureListTest to ensure ScopedFeatureList keeps |
| // features from command line. |
| std::string enabled = |
| command_line->GetSwitchValueASCII(switches::kEnableFeatures); |
| std::string disabled = |
| command_line->GetSwitchValueASCII(switches::kDisableFeatures); |
| enabled += ",TestFeatureForBrowserTest1"; |
| disabled += ",TestFeatureForBrowserTest2"; |
| scoped_feature_list_.InitFromCommandLine(enabled, disabled); |
| |
| // The enable-features and disable-features flags were just slurped into a |
| // FeatureList, so remove them from the command line. Tests should enable |
| // and disable features via the ScopedFeatureList API rather than |
| // command-line flags. |
| CommandLine new_command_line(command_line->GetProgram()); |
| CommandLine::SwitchMap switches = command_line->GetSwitches(); |
| |
| switches.erase(switches::kEnableFeatures); |
| switches.erase(switches::kDisableFeatures); |
| |
| for (const auto& iter : switches) |
| new_command_line.AppendSwitchNative(iter.first, iter.second); |
| |
| *CommandLine::ForCurrentProcess() = new_command_line; |
| |
| // TODO(https://crbug.com/1413674): Enable PartitionAlloc in unittests with |
| // ASAN. |
| #if BUILDFLAG(USE_PARTITION_ALLOC) && !defined(ADDRESS_SANITIZER) |
| allocator::PartitionAllocSupport::Get()->ReconfigureAfterFeatureListInit( |
| "", |
| /*configure_dangling_pointer_detector=*/true); |
| #endif |
| } |
| |
| void OnTestEnd(const testing::TestInfo& test_info) override { |
| scoped_feature_list_.Reset(); |
| } |
| |
| private: |
| test::ScopedFeatureList scoped_feature_list_; |
| }; |
| |
| class CheckForLeakedGlobals : public testing::EmptyTestEventListener { |
| public: |
| CheckForLeakedGlobals() = default; |
| |
| CheckForLeakedGlobals(const CheckForLeakedGlobals&) = delete; |
| CheckForLeakedGlobals& operator=(const CheckForLeakedGlobals&) = delete; |
| |
| // Check for leaks in individual tests. |
| void OnTestStart(const testing::TestInfo& test) override { |
| feature_list_set_before_test_ = FeatureList::GetInstance(); |
| thread_pool_set_before_test_ = ThreadPoolInstance::Get(); |
| } |
| void OnTestEnd(const testing::TestInfo& test) override { |
| DCHECK_EQ(feature_list_set_before_test_, FeatureList::GetInstance()) |
| << " in test " << test.test_case_name() << "." << test.name(); |
| DCHECK_EQ(thread_pool_set_before_test_, ThreadPoolInstance::Get()) |
| << " in test " << test.test_case_name() << "." << test.name(); |
| feature_list_set_before_test_ = nullptr; |
| thread_pool_set_before_test_ = nullptr; |
| } |
| |
| // Check for leaks in test cases (consisting of one or more tests). |
| void OnTestCaseStart(const testing::TestCase& test_case) override { |
| feature_list_set_before_case_ = FeatureList::GetInstance(); |
| thread_pool_set_before_case_ = ThreadPoolInstance::Get(); |
| } |
| void OnTestCaseEnd(const testing::TestCase& test_case) override { |
| DCHECK_EQ(feature_list_set_before_case_, FeatureList::GetInstance()) |
| << " in case " << test_case.name(); |
| DCHECK_EQ(thread_pool_set_before_case_, ThreadPoolInstance::Get()) |
| << " in case " << test_case.name(); |
| feature_list_set_before_case_ = nullptr; |
| thread_pool_set_before_case_ = nullptr; |
| } |
| |
| private: |
| raw_ptr<FeatureList, DanglingUntriaged> feature_list_set_before_test_ = |
| nullptr; |
| raw_ptr<FeatureList> feature_list_set_before_case_ = nullptr; |
| raw_ptr<ThreadPoolInstance> thread_pool_set_before_test_ = nullptr; |
| raw_ptr<ThreadPoolInstance> thread_pool_set_before_case_ = nullptr; |
| }; |
| |
| // iOS: base::Process is not available. |
| // macOS: Tests may run at background priority locally (crbug.com/1358639#c6) or |
| // on bots (crbug.com/931721#c7). |
| #if !BUILDFLAG(IS_APPLE) |
| class CheckProcessPriority : public testing::EmptyTestEventListener { |
| public: |
| CheckProcessPriority() { CHECK(!IsProcessBackgrounded()); } |
| |
| CheckProcessPriority(const CheckProcessPriority&) = delete; |
| CheckProcessPriority& operator=(const CheckProcessPriority&) = delete; |
| |
| void OnTestStart(const testing::TestInfo& test) override { |
| EXPECT_FALSE(IsProcessBackgrounded()); |
| } |
| void OnTestEnd(const testing::TestInfo& test) override { |
| EXPECT_FALSE(IsProcessBackgrounded()); |
| } |
| |
| private: |
| bool IsProcessBackgrounded() const { |
| return Process::Current().IsProcessBackgrounded(); |
| } |
| }; |
| #endif // !BUILDFLAG(IS_APPLE) |
| |
| const std::string& GetProfileName() { |
| static const NoDestructor<std::string> profile_name([]() { |
| const CommandLine& command_line = *CommandLine::ForCurrentProcess(); |
| if (command_line.HasSwitch(switches::kProfilingFile)) |
| return command_line.GetSwitchValueASCII(switches::kProfilingFile); |
| else |
| return std::string("test-profile-{pid}"); |
| }()); |
| return *profile_name; |
| } |
| |
| void InitializeLogging() { |
| #if BUILDFLAG(IS_FUCHSIA) |
| constexpr auto kLoggingDest = logging::LOG_TO_STDERR; |
| #else |
| constexpr auto kLoggingDest = |
| logging::LOG_TO_SYSTEM_DEBUG_LOG | logging::LOG_TO_STDERR; |
| #endif |
| CHECK(logging::InitLogging({.logging_dest = kLoggingDest})); |
| |
| // We want process and thread IDs because we may have multiple processes. |
| #if BUILDFLAG(IS_ANDROID) |
| // To view log output with IDs and timestamps use "adb logcat -v threadtime". |
| logging::SetLogItems(false, false, false, false); |
| #else |
| // We want process and thread IDs because we may have multiple processes. |
| logging::SetLogItems(true, true, false, false); |
| #endif // !BUILDFLAG(IS_ANDROID) |
| } |
| |
| #if BUILDFLAG(IS_WIN) |
| // Handlers for invalid parameter, pure call, and abort. They generate a |
| // breakpoint to ensure that we get a call stack on these failures. |
| // These functions should be written to be unique in order to avoid confusing |
| // call stacks from /OPT:ICF function folding. Printing a unique message or |
| // returning a unique value will do this. Note that for best results they need |
| // to be unique from *all* functions in Chrome. |
| void InvalidParameter(const wchar_t* expression, |
| const wchar_t* function, |
| const wchar_t* file, |
| unsigned int line, |
| uintptr_t reserved) { |
| // CRT printed message is sufficient. |
| __debugbreak(); |
| _exit(1); |
| } |
| |
| void PureCall() { |
| fprintf(stderr, "Pure-virtual function call. Terminating.\n"); |
| __debugbreak(); |
| _exit(1); |
| } |
| |
| void AbortHandler(int signal) { |
| // Print EOL after the CRT abort message. |
| fprintf(stderr, "\n"); |
| __debugbreak(); |
| } |
| #endif |
| |
| } // namespace |
| |
| int RunUnitTestsUsingBaseTestSuite(int argc, char** argv) { |
| TestSuite test_suite(argc, argv); |
| return LaunchUnitTests(argc, argv, |
| BindOnce(&TestSuite::Run, Unretained(&test_suite))); |
| } |
| |
| TestSuite::TestSuite(int argc, char** argv) { |
| Construct(argc, argv); |
| } |
| |
| #if BUILDFLAG(IS_WIN) |
| TestSuite::TestSuite(int argc, wchar_t** argv) { |
| std::vector<std::string> arg_strs; |
| arg_strs.reserve(argc); |
| std::vector<char*> arg_ptrs; |
| arg_ptrs.reserve(argc); |
| std::for_each(argv, argv + argc, [&](wchar_t* arg) { |
| arg_strs.push_back(WideToUTF8(arg)); |
| arg_ptrs.push_back(arg_strs.back().data()); |
| }); |
| Construct(argc, arg_ptrs.data()); |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| |
| TestSuite::~TestSuite() { |
| if (initialized_command_line_) |
| CommandLine::Reset(); |
| } |
| |
| // Don't add additional code to this method. Instead add it to |
| // Initialize(). See bug 6436. |
| int TestSuite::Run() { |
| #if BUILDFLAG(IS_APPLE) |
| mac::ScopedNSAutoreleasePool scoped_pool; |
| #endif |
| |
| std::string client_func = |
| CommandLine::ForCurrentProcess()->GetSwitchValueASCII( |
| switches::kTestChildProcess); |
| |
| #if BUILDFLAG(IS_FUCHSIA) |
| // Cache the system info so individual tests do not need to worry about it. |
| // Some ProcessUtilTest cases, which use kTestChildProcess, do not pass any |
| // services, so skip this if that switch was present. |
| // This must be called before Initialize() because, for example, |
| // content::ContentTestSuite::Initialize() may use the cached values. |
| if (client_func.empty()) |
| CHECK(FetchAndCacheSystemInfo()); |
| #endif |
| |
| Initialize(); |
| |
| // Check to see if we are being run as a client process. |
| if (!client_func.empty()) |
| return multi_process_function_list::InvokeChildProcessTest(client_func); |
| |
| #if BUILDFLAG(IS_IOS) |
| test_listener_ios::RegisterTestEndListener(); |
| #endif |
| |
| #if BUILDFLAG(IS_LINUX) |
| // There's no standard way to opt processes into MTE on Linux just yet, |
| // so this call explicitly opts this test into synchronous MTE mode, where |
| // pointer mismatches are detected immediately. |
| ::partition_alloc::ChangeMemoryTaggingModeForCurrentThread( |
| ::partition_alloc::TagViolationReportingMode::kSynchronous); |
| #elif BUILDFLAG(IS_ANDROID) |
| // On Android, the tests are opted into synchronous MTE mode by the |
| // memtagMode attribute in an AndroidManifest.xml file or via an `am compat` |
| // command, so and explicit call to ChangeMemoryTaggingModeForCurrentThread |
| // is not needed. |
| #endif |
| |
| int result = RunAllTests(); |
| |
| #if BUILDFLAG(IS_APPLE) |
| // This MUST happen before Shutdown() since Shutdown() tears down |
| // objects (such as NotificationService::current()) that Cocoa |
| // objects use to remove themselves as observers. |
| scoped_pool.Recycle(); |
| #endif |
| |
| Shutdown(); |
| |
| return result; |
| } |
| |
| void TestSuite::DisableCheckForThreadAndProcessPriority() { |
| DCHECK(!is_initialized_); |
| check_for_thread_and_process_priority_ = false; |
| } |
| |
| void TestSuite::DisableCheckForLeakedGlobals() { |
| DCHECK(!is_initialized_); |
| check_for_leaked_globals_ = false; |
| } |
| |
| void TestSuite::UnitTestAssertHandler(const char* file, |
| int line, |
| const StringPiece summary, |
| const StringPiece stack_trace) { |
| #if BUILDFLAG(IS_ANDROID) |
| // Correlating test stdio with logcat can be difficult, so we emit this |
| // helpful little hint about what was running. Only do this for Android |
| // because other platforms don't separate out the relevant logs in the same |
| // way. |
| const ::testing::TestInfo* const test_info = |
| ::testing::UnitTest::GetInstance()->current_test_info(); |
| if (test_info) { |
| LOG(ERROR) << "Currently running: " << test_info->test_case_name() << "." |
| << test_info->name(); |
| fflush(stderr); |
| } |
| #endif // BUILDFLAG(IS_ANDROID) |
| |
| // XmlUnitTestResultPrinter inherits gtest format, where assert has summary |
| // and message. In GTest, summary is just a logged text, and message is a |
| // logged text, concatenated with stack trace of assert. |
| // Concatenate summary and stack_trace here, to pass it as a message. |
| if (printer_) { |
| const std::string summary_str(summary); |
| const std::string stack_trace_str = summary_str + std::string(stack_trace); |
| printer_->OnAssert(file, line, summary_str, stack_trace_str); |
| } |
| |
| // The logging system actually prints the message before calling the assert |
| // handler. Just exit now to avoid printing too many stack traces. |
| _exit(1); |
| } |
| |
| void TestSuite::SuppressErrorDialogs() { |
| #if BUILDFLAG(IS_WIN) |
| UINT new_flags = |
| SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX; |
| |
| // Preserve existing error mode, as discussed at |
| // http://blogs.msdn.com/oldnewthing/archive/2004/07/27/198410.aspx |
| UINT existing_flags = SetErrorMode(new_flags); |
| SetErrorMode(existing_flags | new_flags); |
| |
| #if defined(_DEBUG) |
| // Suppress the "Debug Assertion Failed" dialog. |
| // TODO(hbono): remove this code when gtest has it. |
| // http://groups.google.com/d/topic/googletestframework/OjuwNlXy5ac/discussion |
| _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); |
| _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); |
| _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR); |
| _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); |
| #endif // defined(_DEBUG) |
| |
| // See crbug.com/783040 for test code to trigger all of these failures. |
| _set_invalid_parameter_handler(InvalidParameter); |
| _set_purecall_handler(PureCall); |
| signal(SIGABRT, AbortHandler); |
| #endif // BUILDFLAG(IS_WIN) |
| } |
| |
| void TestSuite::Initialize() { |
| DCHECK(!is_initialized_); |
| |
| // The AsanService causes ASAN errors to emit additional information. It is |
| // helpful on its own. It is also required by ASAN BackupRefPtr when |
| // reconfiguring PartitionAlloc below. |
| #if defined(ADDRESS_SANITIZER) |
| base::debug::AsanService::GetInstance()->Initialize(); |
| #endif |
| |
| // TODO(https://crbug.com/1400058): Enable BackupRefPtr in unittests on |
| // Android too. Same for ASAN. |
| // TODO(https://crbug.com/1413674): Enable PartitionAlloc in unittests with |
| // ASAN. |
| #if BUILDFLAG(USE_PARTITION_ALLOC) && !defined(ADDRESS_SANITIZER) |
| allocator::PartitionAllocSupport::Get()->ReconfigureForTests(); |
| #endif // BUILDFLAG(IS_WIN) |
| |
| test::ScopedRunLoopTimeout::SetAddGTestFailureOnTimeout(); |
| |
| const CommandLine* command_line = CommandLine::ForCurrentProcess(); |
| #if !BUILDFLAG(IS_IOS) |
| if (command_line->HasSwitch(switches::kWaitForDebugger)) { |
| debug::WaitForDebugger(60, true); |
| } |
| #endif |
| |
| #if BUILDFLAG(DCHECK_IS_CONFIGURABLE) |
| // Default the configurable DCHECK level to FATAL when running death tests' |
| // child process, so that they behave as expected. |
| // TODO(crbug.com/1057995): Remove this in favor of the codepath in |
| // FeatureList::SetInstance() when/if OnTestStart() TestEventListeners |
| // are fixed to be invoked in the child process as expected. |
| if (command_line->HasSwitch("gtest_internal_run_death_test")) |
| logging::LOGGING_DCHECK = logging::LOG_FATAL; |
| #endif // BUILDFLAG(DCHECK_IS_CONFIGURABLE) |
| |
| #if BUILDFLAG(IS_IOS) |
| InitIOSTestMessageLoop(); |
| #endif // BUILDFLAG(IS_IOS) |
| |
| #if BUILDFLAG(IS_ANDROID) |
| InitAndroidTestMessageLoop(); |
| #endif // else BUILDFLAG(IS_ANDROID) |
| |
| CHECK(debug::EnableInProcessStackDumping()); |
| #if BUILDFLAG(IS_WIN) |
| RouteStdioToConsole(true); |
| // Make sure we run with high resolution timer to minimize differences |
| // between production code and test code. |
| Time::EnableHighResolutionTimer(true); |
| #endif // BUILDFLAG(IS_WIN) |
| |
| // In some cases, we do not want to see standard error dialogs. |
| if (!debug::BeingDebugged() && |
| !command_line->HasSwitch("show-error-dialogs")) { |
| SuppressErrorDialogs(); |
| debug::SetSuppressDebugUI(true); |
| assert_handler_ = std::make_unique<logging::ScopedLogAssertHandler>( |
| BindRepeating(&TestSuite::UnitTestAssertHandler, Unretained(this))); |
| } |
| |
| // Child processes generally do not need ICU. |
| if (!command_line->HasSwitch("test-child-process")) { |
| test::InitializeICUForTesting(); |
| |
| // A number of tests only work if the locale is en_US. This can be an issue |
| // on all platforms. To fix this we force the default locale to en_US. This |
| // does not affect tests that explicitly overrides the locale for testing. |
| // TODO(jshin): Should we set the locale via an OS X locale API here? |
| i18n::SetICUDefaultLocale("en_US"); |
| } |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| test_fonts::SetUpFontconfig(); |
| #endif |
| |
| // Add TestEventListeners to enforce certain properties across tests. |
| testing::TestEventListeners& listeners = |
| testing::UnitTest::GetInstance()->listeners(); |
| listeners.Append(new DisableMaybeTests); |
| listeners.Append(new ResetCommandLineBetweenTests); |
| listeners.Append(new FeatureListScopedToEachTest); |
| if (check_for_leaked_globals_) |
| listeners.Append(new CheckForLeakedGlobals); |
| if (check_for_thread_and_process_priority_) { |
| #if !BUILDFLAG(IS_APPLE) |
| listeners.Append(new CheckProcessPriority); |
| #endif |
| } |
| |
| AddTestLauncherResultPrinter(); |
| |
| TestTimeouts::Initialize(); |
| |
| #if BUILDFLAG(ENABLE_BASE_TRACING) |
| trace_to_file_.BeginTracingFromCommandLineOptions(); |
| #endif // BUILDFLAG(ENABLE_BASE_TRACING) |
| |
| debug::StartProfiling(GetProfileName()); |
| |
| debug::VerifyDebugger(); |
| |
| is_initialized_ = true; |
| } |
| |
| void TestSuite::InitializeFromCommandLine(int argc, char** argv) { |
| initialized_command_line_ = CommandLine::Init(argc, argv); |
| testing::InitGoogleTest(&argc, argv); |
| testing::InitGoogleMock(&argc, argv); |
| |
| #if BUILDFLAG(IS_IOS) |
| InitIOSArgs(argc, argv); |
| #endif |
| } |
| |
| int TestSuite::RunAllTests() { |
| return RUN_ALL_TESTS(); |
| } |
| |
| void TestSuite::Shutdown() { |
| DCHECK(is_initialized_); |
| debug::StopProfiling(); |
| } |
| |
| void TestSuite::Construct(int argc, char** argv) { |
| PreInitialize(); |
| InitializeFromCommandLine(argc, argv); |
| // Logging must be initialized before any thread has a chance to call logging |
| // functions. |
| InitializeLogging(); |
| } |
| |
| void TestSuite::PreInitialize() { |
| DCHECK(!is_initialized_); |
| |
| #if BUILDFLAG(IS_WIN) |
| base::debug::HandleHooks::PatchLoadedModules(); |
| #endif // BUILDFLAG(IS_WIN) |
| |
| // The default death_test_style of "fast" is a frequent source of subtle test |
| // flakiness. And on some platforms like macOS, use of system libraries after |
| // fork() but before exec() is unsafe. Using the threadsafe style by default |
| // alleviates these concerns. |
| // |
| // However, the threasafe style does not work reliably on Android, so that |
| // will keep the default of "fast". See https://crbug.com/815537, |
| // https://github.com/google/googletest/issues/1496, and |
| // https://github.com/google/googletest/issues/2093. |
| // TODO(danakj): Determine if all death tests should be skipped on Android |
| // (many already are, such as for DCHECK-death tests). |
| #if !BUILDFLAG(IS_ANDROID) |
| testing::GTEST_FLAG(death_test_style) = "threadsafe"; |
| #endif |
| |
| #if BUILDFLAG(IS_WIN) |
| testing::GTEST_FLAG(catch_exceptions) = false; |
| #endif |
| EnableTerminationOnHeapCorruption(); |
| #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && defined(USE_AURA) |
| // When calling native char conversion functions (e.g wrctomb) we need to |
| // have the locale set. In the absence of such a call the "C" locale is the |
| // default. In the gtk code (below) gtk_init() implicitly sets a locale. |
| setlocale(LC_ALL, ""); |
| // We still need number to string conversions to be locale insensitive. |
| setlocale(LC_NUMERIC, "C"); |
| #endif // (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && defined(USE_AURA) |
| |
| // On Android, AtExitManager is created in |
| // testing/android/native_test_wrapper.cc before main() is called. |
| #if !BUILDFLAG(IS_ANDROID) |
| at_exit_manager_ = std::make_unique<AtExitManager>(); |
| #endif |
| |
| // Don't add additional code to this function. Instead add it to |
| // Initialize(). See bug 6436. |
| } |
| |
| void TestSuite::AddTestLauncherResultPrinter() { |
| // Only add the custom printer if requested. |
| if (!CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kTestLauncherOutput)) { |
| return; |
| } |
| |
| FilePath output_path(CommandLine::ForCurrentProcess()->GetSwitchValuePath( |
| switches::kTestLauncherOutput)); |
| |
| // Do not add the result printer if output path already exists. It's an |
| // indicator there is a process printing to that file, and we're likely |
| // its child. Do not clobber the results in that case. |
| if (PathExists(output_path)) { |
| LOG(WARNING) << "Test launcher output path " << output_path.AsUTF8Unsafe() |
| << " exists. Not adding test launcher result printer."; |
| return; |
| } |
| |
| printer_ = new XmlUnitTestResultPrinter; |
| CHECK(printer_->Initialize(output_path)) |
| << "Output path is " << output_path.AsUTF8Unsafe() |
| << " and PathExists(output_path) is " << PathExists(output_path); |
| testing::TestEventListeners& listeners = |
| testing::UnitTest::GetInstance()->listeners(); |
| listeners.Append(printer_); |
| } |
| |
| } // namespace base |