| // Copyright 2019 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/launcher/test_launcher.h" |
| |
| #include <stddef.h> |
| |
| #include "base/base64.h" |
| #include "base/command_line.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/logging.h" |
| #include "base/no_destructor.h" |
| #include "base/process/launch.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/string_split.h" |
| #include "base/strings/string_util.h" |
| #include "base/test/gtest_xml_util.h" |
| #include "base/test/launcher/test_launcher_test_utils.h" |
| #include "base/test/launcher/unit_test_launcher.h" |
| #include "base/test/multiprocess_test.h" |
| #include "base/test/scoped_logging_settings.h" |
| #include "base/test/task_environment.h" |
| #include "base/test/test_timeouts.h" |
| #include "base/time/time_to_iso8601.h" |
| #include "build/build_config.h" |
| #include "build/chromeos_buildflags.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "testing/multiprocess_func_list.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| |
| namespace base { |
| namespace { |
| |
| using ::testing::_; |
| using ::testing::DoAll; |
| using ::testing::Invoke; |
| using ::testing::InvokeWithoutArgs; |
| using ::testing::Return; |
| using ::testing::ReturnPointee; |
| |
| TestResult GenerateTestResult(const std::string& test_name, |
| TestResult::Status status, |
| TimeDelta elapsed_td = Milliseconds(30), |
| const std::string& output_snippet = "output") { |
| TestResult result; |
| result.full_name = test_name; |
| result.status = status; |
| result.elapsed_time = elapsed_td; |
| result.output_snippet = output_snippet; |
| return result; |
| } |
| |
| TestResultPart GenerateTestResultPart(TestResultPart::Type type, |
| const std::string& file_name, |
| int line_number, |
| const std::string& summary, |
| const std::string& message) { |
| TestResultPart test_result_part; |
| test_result_part.type = type; |
| test_result_part.file_name = file_name; |
| test_result_part.line_number = line_number; |
| test_result_part.summary = summary; |
| test_result_part.message = message; |
| return test_result_part; |
| } |
| |
| // Mock TestLauncher to mock CreateAndStartThreadPool, |
| // unit test will provide a TaskEnvironment. |
| class MockTestLauncher : public TestLauncher { |
| public: |
| MockTestLauncher(TestLauncherDelegate* launcher_delegate, |
| size_t parallel_jobs) |
| : TestLauncher(launcher_delegate, parallel_jobs) {} |
| |
| void CreateAndStartThreadPool(size_t parallel_jobs) override {} |
| |
| MOCK_METHOD4(LaunchChildGTestProcess, |
| void(scoped_refptr<TaskRunner> task_runner, |
| const std::vector<std::string>& test_names, |
| const FilePath& task_temp_dir, |
| const FilePath& child_temp_dir)); |
| }; |
| |
| // Simple TestLauncherDelegate mock to test TestLauncher flow. |
| class MockTestLauncherDelegate : public TestLauncherDelegate { |
| public: |
| MOCK_METHOD1(GetTests, bool(std::vector<TestIdentifier>* output)); |
| MOCK_METHOD2(WillRunTest, |
| bool(const std::string& test_case_name, |
| const std::string& test_name)); |
| MOCK_METHOD2(ProcessTestResults, |
| void(std::vector<TestResult>& test_names, |
| TimeDelta elapsed_time)); |
| MOCK_METHOD3(GetCommandLine, |
| CommandLine(const std::vector<std::string>& test_names, |
| const FilePath& temp_dir_, |
| FilePath* output_file_)); |
| MOCK_METHOD1(IsPreTask, bool(const std::vector<std::string>& test_names)); |
| MOCK_METHOD0(GetWrapper, std::string()); |
| MOCK_METHOD0(GetLaunchOptions, int()); |
| MOCK_METHOD0(GetTimeout, TimeDelta()); |
| MOCK_METHOD0(GetBatchSize, size_t()); |
| }; |
| |
| class MockResultWatcher : public ResultWatcher { |
| public: |
| MockResultWatcher(FilePath result_file, size_t num_tests) |
| : ResultWatcher(result_file, num_tests) {} |
| |
| MOCK_METHOD(bool, WaitWithTimeout, (TimeDelta), (override)); |
| }; |
| |
| // Using MockTestLauncher to test TestLauncher. |
| // Test TestLauncher filters, and command line switches setup. |
| class TestLauncherTest : public testing::Test { |
| protected: |
| TestLauncherTest() |
| : command_line(new CommandLine(CommandLine::NO_PROGRAM)), |
| test_launcher(&delegate, 10) {} |
| |
| // Adds tests to be returned by the delegate. |
| void AddMockedTests(std::string test_case_name, |
| const std::vector<std::string>& test_names) { |
| for (const std::string& test_name : test_names) { |
| TestIdentifier test_data; |
| test_data.test_case_name = test_case_name; |
| test_data.test_name = test_name; |
| test_data.file = "File"; |
| test_data.line = 100; |
| tests_.push_back(test_data); |
| } |
| } |
| |
| // Setup expected delegate calls, and which tests the delegate will return. |
| void SetUpExpectCalls(size_t batch_size = 10) { |
| EXPECT_CALL(delegate, GetTests(_)) |
| .WillOnce(::testing::DoAll(testing::SetArgPointee<0>(tests_), |
| testing::Return(true))); |
| EXPECT_CALL(delegate, WillRunTest(_, _)) |
| .WillRepeatedly(testing::Return(true)); |
| EXPECT_CALL(delegate, ProcessTestResults(_, _)).Times(0); |
| EXPECT_CALL(delegate, GetCommandLine(_, _, _)) |
| .WillRepeatedly(testing::Return(CommandLine(CommandLine::NO_PROGRAM))); |
| EXPECT_CALL(delegate, GetWrapper()) |
| .WillRepeatedly(testing::Return(std::string())); |
| EXPECT_CALL(delegate, IsPreTask(_)).WillRepeatedly(testing::Return(true)); |
| EXPECT_CALL(delegate, GetLaunchOptions()) |
| .WillRepeatedly(testing::Return(true)); |
| EXPECT_CALL(delegate, GetTimeout()) |
| .WillRepeatedly(testing::Return(TimeDelta())); |
| EXPECT_CALL(delegate, GetBatchSize()) |
| .WillRepeatedly(testing::Return(batch_size)); |
| } |
| |
| std::unique_ptr<CommandLine> command_line; |
| MockTestLauncher test_launcher; |
| MockTestLauncherDelegate delegate; |
| base::test::TaskEnvironment task_environment{ |
| base::test::TaskEnvironment::MainThreadType::IO}; |
| ScopedTempDir dir; |
| |
| FilePath CreateFilterFile() { |
| FilePath result_file = dir.GetPath().AppendASCII("test.filter"); |
| WriteFile(result_file, "-Test.firstTest"); |
| return result_file; |
| } |
| |
| private: |
| std::vector<TestIdentifier> tests_; |
| }; |
| |
| class ResultWatcherTest : public testing::Test { |
| protected: |
| ResultWatcherTest() = default; |
| |
| FilePath CreateResultFile() { |
| FilePath result_file = dir.GetPath().AppendASCII("test_results.xml"); |
| WriteFile(result_file, |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| "<testsuites>\n" |
| " <testsuite>\n"); |
| return result_file; |
| } |
| |
| base::test::TaskEnvironment task_environment{ |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME}; |
| ScopedTempDir dir; |
| }; |
| |
| // Action to mock delegate invoking OnTestFinish on test launcher. |
| ACTION_P3(OnTestResult, launcher, full_name, status) { |
| TestResult result = GenerateTestResult(full_name, status); |
| arg0->PostTask(FROM_HERE, BindOnce(&TestLauncher::OnTestFinished, |
| Unretained(launcher), result)); |
| } |
| |
| // Action to mock delegate invoking OnTestFinish on test launcher. |
| ACTION_P2(OnTestResult, launcher, result) { |
| arg0->PostTask(FROM_HERE, BindOnce(&TestLauncher::OnTestFinished, |
| Unretained(launcher), result)); |
| } |
| |
| // A test and a disabled test cannot share a name. |
| TEST_F(TestLauncherTest, TestNameSharedWithDisabledTest) { |
| AddMockedTests("Test", {"firstTest", "DISABLED_firstTest"}); |
| SetUpExpectCalls(); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // A test case and a disabled test case cannot share a name. |
| TEST_F(TestLauncherTest, TestNameSharedWithDisabledTestCase) { |
| AddMockedTests("DISABLED_Test", {"firstTest"}); |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Compiled tests should not contain an orphaned pre test. |
| TEST_F(TestLauncherTest, OrphanePreTest) { |
| AddMockedTests("Test", {"firstTest", "PRE_firstTestOrphane"}); |
| SetUpExpectCalls(); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // When There are no tests, delegate should not be called. |
| TEST_F(TestLauncherTest, EmptyTestSetPasses) { |
| SetUpExpectCalls(); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)).Times(0); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher filters DISABLED tests by default. |
| TEST_F(TestLauncherTest, FilterDisabledTestByDefault) { |
| AddMockedTests("DISABLED_TestDisabled", {"firstTest"}); |
| AddMockedTests("Test", |
| {"firstTest", "secondTest", "DISABLED_firstTestDisabled"}); |
| SetUpExpectCalls(); |
| std::vector<std::string> tests_names = {"Test.firstTest", "Test.secondTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "Test.secondTest", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher should reorder PRE_ tests before delegate |
| TEST_F(TestLauncherTest, ReorderPreTests) { |
| AddMockedTests("Test", {"firstTest", "PRE_PRE_firstTest", "PRE_firstTest"}); |
| SetUpExpectCalls(); |
| std::vector<std::string> tests_names = { |
| "Test.PRE_PRE_firstTest", "Test.PRE_firstTest", "Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .Times(1); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher "gtest_filter" switch. |
| TEST_F(TestLauncherTest, UsingCommandLineFilter) { |
| AddMockedTests("Test", |
| {"firstTest", "secondTest", "DISABLED_firstTestDisabled"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("gtest_filter", "Test*.first*"); |
| std::vector<std::string> tests_names = {"Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher gtest filter will include pre tests |
| TEST_F(TestLauncherTest, FilterIncludePreTest) { |
| AddMockedTests("Test", {"firstTest", "secondTest", "PRE_firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("gtest_filter", "Test.firstTest"); |
| std::vector<std::string> tests_names = {"Test.PRE_firstTest", |
| "Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .Times(1); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher gtest filter works when both include and exclude filter |
| // are defined. |
| TEST_F(TestLauncherTest, FilterIncludeExclude) { |
| AddMockedTests("Test", {"firstTest", "PRE_firstTest", "secondTest", |
| "PRE_secondTest", "thirdTest", "DISABLED_Disable1"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("gtest_filter", |
| "Test.*Test:-Test.secondTest"); |
| std::vector<std::string> tests_names = { |
| "Test.PRE_firstTest", |
| "Test.firstTest", |
| "Test.thirdTest", |
| }; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .Times(1); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher "gtest_repeat" switch. |
| TEST_F(TestLauncherTest, RepeatTest) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| // Unless --gtest-break-on-failure is specified, |
| command_line->AppendSwitchASCII("gtest_repeat", "2"); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .Times(2) |
| .WillRepeatedly(::testing::DoAll(OnTestResult( |
| &test_launcher, "Test.firstTest", TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher --gtest_repeat and --gtest_break_on_failure. |
| TEST_F(TestLauncherTest, RunningMultipleIterationsUntilFailure) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| // Unless --gtest-break-on-failure is specified, |
| command_line->AppendSwitchASCII("gtest_repeat", "4"); |
| command_line->AppendSwitch("gtest_break_on_failure"); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS))) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS))) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_FAILURE))); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher will retry failed test, and stop on success. |
| TEST_F(TestLauncherTest, SuccessOnRetryTests) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-retry-limit", "2"); |
| std::vector<std::string> tests_names = {"Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_FAILURE)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher will retry continuing failing test up to retry limit, |
| // before eventually failing and returning false. |
| TEST_F(TestLauncherTest, FailOnRetryTests) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-retry-limit", "2"); |
| std::vector<std::string> tests_names = {"Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .Times(3) |
| .WillRepeatedly(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_FAILURE)); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher should retry all PRE_ chained tests |
| TEST_F(TestLauncherTest, RetryPreTests) { |
| AddMockedTests("Test", {"firstTest", "PRE_PRE_firstTest", "PRE_firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-retry-limit", "2"); |
| std::vector<TestResult> results = { |
| GenerateTestResult("Test.PRE_PRE_firstTest", TestResult::TEST_SUCCESS), |
| GenerateTestResult("Test.PRE_firstTest", TestResult::TEST_FAILURE), |
| GenerateTestResult("Test.firstTest", TestResult::TEST_SUCCESS)}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(::testing::DoAll( |
| OnTestResult(&test_launcher, "Test.PRE_PRE_firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "Test.PRE_firstTest", |
| TestResult::TEST_FAILURE), |
| OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS))); |
| std::vector<std::string> tests_names = {"Test.PRE_PRE_firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.PRE_PRE_firstTest", |
| TestResult::TEST_SUCCESS)); |
| tests_names = {"Test.PRE_firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.PRE_firstTest", |
| TestResult::TEST_SUCCESS)); |
| tests_names = {"Test.firstTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher should fail if a PRE test fails but its non-PRE test passes |
| TEST_F(TestLauncherTest, PreTestFailure) { |
| AddMockedTests("Test", {"FirstTest", "PRE_FirstTest"}); |
| SetUpExpectCalls(); |
| std::vector<TestResult> results = { |
| GenerateTestResult("Test.PRE_FirstTest", TestResult::TEST_FAILURE), |
| GenerateTestResult("Test.FirstTest", TestResult::TEST_SUCCESS)}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce( |
| ::testing::DoAll(OnTestResult(&test_launcher, "Test.PRE_FirstTest", |
| TestResult::TEST_FAILURE), |
| OnTestResult(&test_launcher, "Test.FirstTest", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_CALL(test_launcher, |
| LaunchChildGTestProcess( |
| _, testing::ElementsAre("Test.PRE_FirstTest"), _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.PRE_FirstTest", |
| TestResult::TEST_FAILURE)); |
| EXPECT_CALL( |
| test_launcher, |
| LaunchChildGTestProcess(_, testing::ElementsAre("Test.FirstTest"), _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.FirstTest", |
| TestResult::TEST_SUCCESS)); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher run disabled unit tests switch. |
| TEST_F(TestLauncherTest, RunDisabledTests) { |
| AddMockedTests("DISABLED_TestDisabled", {"firstTest"}); |
| AddMockedTests("Test", |
| {"firstTest", "secondTest", "DISABLED_firstTestDisabled"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitch("gtest_also_run_disabled_tests"); |
| command_line->AppendSwitchASCII("gtest_filter", "Test*.first*"); |
| std::vector<std::string> tests_names = {"DISABLED_TestDisabled.firstTest", |
| "Test.firstTest", |
| "Test.DISABLED_firstTestDisabled"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(::testing::DoAll( |
| OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "DISABLED_TestDisabled.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "Test.DISABLED_firstTestDisabled", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher does not run negative tests filtered under |
| // testing/buildbot/filters. |
| TEST_F(TestLauncherTest, DoesRunFilteredTests) { |
| AddMockedTests("Test", {"firstTest", "secondTest"}); |
| SetUpExpectCalls(); |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| // filter file content is "-Test.firstTest" |
| FilePath path = CreateFilterFile(); |
| command_line->AppendSwitchPath("test-launcher-filter-file", path); |
| std::vector<std::string> tests_names = {"Test.secondTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.secondTest", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Test TestLauncher run disabled tests and negative tests filtered under |
| // testing/buildbot/filters, when gtest_also_run_disabled_tests is set. |
| TEST_F(TestLauncherTest, RunDisabledTestsWithFilteredTests) { |
| AddMockedTests("DISABLED_TestDisabled", {"firstTest"}); |
| AddMockedTests("Test", {"firstTest", "DISABLED_firstTestDisabled"}); |
| SetUpExpectCalls(); |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| // filter file content is "-Test.firstTest", but Test.firstTest will still |
| // run due to gtest_also_run_disabled_tests is set. |
| FilePath path = CreateFilterFile(); |
| command_line->AppendSwitchPath("test-launcher-filter-file", path); |
| command_line->AppendSwitch("gtest_also_run_disabled_tests"); |
| std::vector<std::string> tests_names = {"DISABLED_TestDisabled.firstTest", |
| "Test.firstTest", |
| "Test.DISABLED_firstTestDisabled"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(::testing::DoAll( |
| OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "DISABLED_TestDisabled.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "Test.DISABLED_firstTestDisabled", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Disabled test should disable all pre tests |
| TEST_F(TestLauncherTest, DisablePreTests) { |
| AddMockedTests("Test", {"DISABLED_firstTest", "PRE_PRE_firstTest", |
| "PRE_firstTest", "secondTest"}); |
| SetUpExpectCalls(); |
| std::vector<std::string> tests_names = {"Test.secondTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .Times(1); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Tests fail if they produce too much output. |
| TEST_F(TestLauncherTest, ExcessiveOutput) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-retry-limit", "0"); |
| command_line->AppendSwitchASCII("test-launcher-print-test-stdio", "never"); |
| TestResult test_result = |
| GenerateTestResult("Test.firstTest", TestResult::TEST_SUCCESS, |
| Milliseconds(30), std::string(500000, 'a')); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(OnTestResult(&test_launcher, test_result)); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Use command-line switch to allow more output. |
| TEST_F(TestLauncherTest, OutputLimitSwitch) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-print-test-stdio", "never"); |
| command_line->AppendSwitchASCII("test-launcher-output-bytes-limit", "800000"); |
| TestResult test_result = |
| GenerateTestResult("Test.firstTest", TestResult::TEST_SUCCESS, |
| Milliseconds(30), std::string(500000, 'a')); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(OnTestResult(&test_launcher, test_result)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Shard index must be lesser than total shards |
| TEST_F(TestLauncherTest, FaultyShardSetup) { |
| command_line->AppendSwitchASCII("test-launcher-total-shards", "2"); |
| command_line->AppendSwitchASCII("test-launcher-shard-index", "2"); |
| EXPECT_FALSE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Shard index must be lesser than total shards |
| TEST_F(TestLauncherTest, RedirectStdio) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-print-test-stdio", "always"); |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Sharding should be stable and always selecting the same tests. |
| TEST_F(TestLauncherTest, StableSharding) { |
| AddMockedTests("Test", {"firstTest", "secondTest", "thirdTest"}); |
| SetUpExpectCalls(); |
| command_line->AppendSwitchASCII("test-launcher-total-shards", "2"); |
| command_line->AppendSwitchASCII("test-launcher-shard-index", "0"); |
| command_line->AppendSwitch("test-launcher-stable-sharding"); |
| std::vector<std::string> tests_names = {"Test.firstTest", "Test.secondTest"}; |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess( |
| _, |
| testing::ElementsAreArray(tests_names.cbegin(), |
| tests_names.cend()), |
| _, _)) |
| .WillOnce(::testing::DoAll(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS), |
| OnTestResult(&test_launcher, "Test.secondTest", |
| TestResult::TEST_SUCCESS))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| } |
| |
| // Validate |iteration_data| contains one test result matching |result|. |
| bool ValidateTestResultObject(const Value::Dict& iteration_data, |
| TestResult& test_result) { |
| const Value::List* results = iteration_data.FindList(test_result.full_name); |
| if (!results) { |
| ADD_FAILURE() << "Results not found"; |
| return false; |
| } |
| if (1u != results->size()) { |
| ADD_FAILURE() << "Expected one result, actual: " << results->size(); |
| return false; |
| } |
| const Value::Dict* dict = (*results)[0].GetIfDict(); |
| if (!dict) { |
| ADD_FAILURE() << "Unexpected type"; |
| return false; |
| } |
| |
| using test_launcher_utils::ValidateKeyValue; |
| bool result = ValidateKeyValue(*dict, "elapsed_time_ms", |
| test_result.elapsed_time.InMilliseconds()); |
| |
| if (!dict->FindBool("losless_snippet").value_or(false)) { |
| ADD_FAILURE() << "losless_snippet expected to be true"; |
| result = false; |
| } |
| |
| result &= |
| ValidateKeyValue(*dict, "output_snippet", test_result.output_snippet); |
| |
| std::string base64_output_snippet; |
| Base64Encode(test_result.output_snippet, &base64_output_snippet); |
| result &= |
| ValidateKeyValue(*dict, "output_snippet_base64", base64_output_snippet); |
| |
| result &= ValidateKeyValue(*dict, "status", test_result.StatusAsString()); |
| |
| const Value::List* list = dict->FindList("result_parts"); |
| if (test_result.test_result_parts.size() != list->size()) { |
| ADD_FAILURE() << "test_result_parts count is not valid"; |
| return false; |
| } |
| |
| for (unsigned i = 0; i < test_result.test_result_parts.size(); i++) { |
| TestResultPart result_part = test_result.test_result_parts.at(i); |
| const Value::Dict& part_dict = (*list)[i].GetDict(); |
| |
| result &= ValidateKeyValue(part_dict, "type", result_part.TypeAsString()); |
| result &= ValidateKeyValue(part_dict, "file", result_part.file_name); |
| result &= ValidateKeyValue(part_dict, "line", result_part.line_number); |
| result &= ValidateKeyValue(part_dict, "summary", result_part.summary); |
| result &= ValidateKeyValue(part_dict, "message", result_part.message); |
| } |
| return result; |
| } |
| |
| // Validate |root| dictionary value contains a list with |values| |
| // at |key| value. |
| bool ValidateStringList(const absl::optional<Value::Dict>& root, |
| const std::string& key, |
| std::vector<const char*> values) { |
| const Value::List* list = root->FindList(key); |
| if (!list) { |
| ADD_FAILURE() << "|root| has no list_value in key: " << key; |
| return false; |
| } |
| |
| if (values.size() != list->size()) { |
| ADD_FAILURE() << "expected size: " << values.size() |
| << ", actual size:" << list->size(); |
| return false; |
| } |
| |
| for (unsigned i = 0; i < values.size(); i++) { |
| if (!(*list)[i].is_string() && |
| (*list)[i].GetString().compare(values.at(i))) { |
| ADD_FAILURE() << "Expected list values do not match actual list"; |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| // Unit tests to validate TestLauncher outputs the correct JSON file. |
| TEST_F(TestLauncherTest, JsonSummary) { |
| AddMockedTests("DISABLED_TestDisabled", {"firstTest"}); |
| AddMockedTests("Test", |
| {"firstTest", "secondTest", "DISABLED_firstTestDisabled"}); |
| SetUpExpectCalls(); |
| |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath path = dir.GetPath().AppendASCII("SaveSummaryResult.json"); |
| command_line->AppendSwitchPath("test-launcher-summary-output", path); |
| command_line->AppendSwitchASCII("gtest_repeat", "2"); |
| // Force the repeats to run sequentially. |
| command_line->AppendSwitch("gtest_break_on_failure"); |
| |
| // Setup results to be returned by the test launcher delegate. |
| TestResult first_result = |
| GenerateTestResult("Test.firstTest", TestResult::TEST_SUCCESS, |
| Milliseconds(30), "output_first"); |
| first_result.test_result_parts.push_back(GenerateTestResultPart( |
| TestResultPart::kSuccess, "TestFile", 110, "summary", "message")); |
| TestResult second_result = |
| GenerateTestResult("Test.secondTest", TestResult::TEST_SUCCESS, |
| Milliseconds(50), "output_second"); |
| |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .Times(2) |
| .WillRepeatedly( |
| ::testing::DoAll(OnTestResult(&test_launcher, first_result), |
| OnTestResult(&test_launcher, second_result))); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| |
| // Validate the resulting JSON file is the expected output. |
| absl::optional<Value::Dict> root = test_launcher_utils::ReadSummary(path); |
| ASSERT_TRUE(root); |
| EXPECT_TRUE( |
| ValidateStringList(root, "all_tests", |
| {"Test.firstTest", "Test.firstTestDisabled", |
| "Test.secondTest", "TestDisabled.firstTest"})); |
| EXPECT_TRUE( |
| ValidateStringList(root, "disabled_tests", |
| {"Test.firstTestDisabled", "TestDisabled.firstTest"})); |
| |
| const Value::Dict* dict = root->FindDict("test_locations"); |
| ASSERT_TRUE(dict); |
| EXPECT_EQ(2u, dict->size()); |
| ASSERT_TRUE(test_launcher_utils::ValidateTestLocation(*dict, "Test.firstTest", |
| "File", 100)); |
| ASSERT_TRUE(test_launcher_utils::ValidateTestLocation( |
| *dict, "Test.secondTest", "File", 100)); |
| |
| const Value::List* list = root->FindList("per_iteration_data"); |
| ASSERT_TRUE(list); |
| ASSERT_EQ(2u, list->size()); |
| for (const auto& iteration_val : *list) { |
| ASSERT_TRUE(iteration_val.is_dict()); |
| const base::Value::Dict& iteration_dict = iteration_val.GetDict(); |
| EXPECT_EQ(2u, iteration_dict.size()); |
| EXPECT_TRUE(ValidateTestResultObject(iteration_dict, first_result)); |
| EXPECT_TRUE(ValidateTestResultObject(iteration_dict, second_result)); |
| } |
| } |
| |
| // Validate TestLauncher outputs the correct JSON file |
| // when running disabled tests. |
| TEST_F(TestLauncherTest, JsonSummaryWithDisabledTests) { |
| AddMockedTests("Test", {"DISABLED_Test"}); |
| SetUpExpectCalls(); |
| |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath path = dir.GetPath().AppendASCII("SaveSummaryResult.json"); |
| command_line->AppendSwitchPath("test-launcher-summary-output", path); |
| command_line->AppendSwitch("gtest_also_run_disabled_tests"); |
| |
| // Setup results to be returned by the test launcher delegate. |
| TestResult test_result = |
| GenerateTestResult("Test.DISABLED_Test", TestResult::TEST_SUCCESS, |
| Milliseconds(50), "output_second"); |
| |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillOnce(OnTestResult(&test_launcher, test_result)); |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| |
| // Validate the resulting JSON file is the expected output. |
| absl::optional<Value::Dict> root = test_launcher_utils::ReadSummary(path); |
| ASSERT_TRUE(root); |
| Value::Dict* dict = root->FindDict("test_locations"); |
| ASSERT_TRUE(dict); |
| EXPECT_EQ(1u, dict->size()); |
| EXPECT_TRUE(test_launcher_utils::ValidateTestLocation( |
| *dict, "Test.DISABLED_Test", "File", 100)); |
| |
| Value::List* list = root->FindList("per_iteration_data"); |
| ASSERT_TRUE(list); |
| ASSERT_EQ(1u, list->size()); |
| |
| Value::Dict* iteration_dict = (*list)[0].GetIfDict(); |
| ASSERT_TRUE(iteration_dict); |
| EXPECT_EQ(1u, iteration_dict->size()); |
| // We expect the result to be stripped of disabled prefix. |
| test_result.full_name = "Test.Test"; |
| EXPECT_TRUE(ValidateTestResultObject(*iteration_dict, test_result)); |
| } |
| |
| // Matches a std::tuple<const FilePath&, const FilePath&> where the first |
| // item is a parent of the second. |
| MATCHER(DirectoryIsParentOf, "") { |
| return std::get<0>(arg).IsParent(std::get<1>(arg)); |
| } |
| |
| // Test that the launcher creates a dedicated temp dir for a child proc and |
| // cleans it up. |
| TEST_F(TestLauncherTest, TestChildTempDir) { |
| AddMockedTests("Test", {"firstTest"}); |
| SetUpExpectCalls(); |
| ON_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, _)) |
| .WillByDefault(OnTestResult(&test_launcher, "Test.firstTest", |
| TestResult::TEST_SUCCESS)); |
| |
| FilePath task_temp; |
| if (TestLauncher::SupportsPerChildTempDirs()) { |
| // Platforms that support child proc temp dirs must get a |child_temp_dir| |
| // arg that exists and is within |task_temp_dir|. |
| EXPECT_CALL( |
| test_launcher, |
| LaunchChildGTestProcess( |
| _, _, _, ::testing::ResultOf(DirectoryExists, ::testing::IsTrue()))) |
| .With(::testing::Args<2, 3>(DirectoryIsParentOf())) |
| .WillOnce(::testing::SaveArg<2>(&task_temp)); |
| } else { |
| // Platforms that don't support child proc temp dirs must get an empty |
| // |child_temp_dir| arg. |
| EXPECT_CALL(test_launcher, LaunchChildGTestProcess(_, _, _, FilePath())) |
| .WillOnce(::testing::SaveArg<2>(&task_temp)); |
| } |
| |
| EXPECT_TRUE(test_launcher.Run(command_line.get())); |
| |
| // The task's temporary directory should have been deleted. |
| EXPECT_FALSE(DirectoryExists(task_temp)); |
| } |
| |
| #if BUILDFLAG(IS_FUCHSIA) |
| // Verifies that test processes have /data, /cache and /tmp available. |
| TEST_F(TestLauncherTest, ProvidesDataCacheAndTmpDirs) { |
| EXPECT_TRUE(base::DirectoryExists(base::FilePath("/data"))); |
| EXPECT_TRUE(base::DirectoryExists(base::FilePath("/cache"))); |
| EXPECT_TRUE(base::DirectoryExists(base::FilePath("/tmp"))); |
| } |
| #endif // BUILDFLAG(IS_FUCHSIA) |
| |
| // Unit tests to validate UnitTestLauncherDelegate implementation. |
| class UnitTestLauncherDelegateTester : public testing::Test { |
| protected: |
| DefaultUnitTestPlatformDelegate defaultPlatform; |
| ScopedTempDir dir; |
| |
| private: |
| base::test::TaskEnvironment task_environment; |
| }; |
| |
| // Validate delegate produces correct command line. |
| TEST_F(UnitTestLauncherDelegateTester, GetCommandLine) { |
| UnitTestLauncherDelegate launcher_delegate(&defaultPlatform, 10u, true, |
| DoNothing()); |
| TestLauncherDelegate* delegate_ptr = &launcher_delegate; |
| |
| std::vector<std::string> test_names(5, "Tests"); |
| base::FilePath temp_dir; |
| base::FilePath result_file; |
| CreateNewTempDirectory(FilePath::StringType(), &temp_dir); |
| |
| CommandLine cmd_line = |
| delegate_ptr->GetCommandLine(test_names, temp_dir, &result_file); |
| EXPECT_TRUE(cmd_line.HasSwitch("single-process-tests")); |
| EXPECT_EQ(cmd_line.GetSwitchValuePath("test-launcher-output"), result_file); |
| |
| const int size = 2048; |
| std::string content; |
| ASSERT_TRUE(ReadFileToStringWithMaxSize( |
| cmd_line.GetSwitchValuePath("gtest_flagfile"), &content, size)); |
| EXPECT_EQ(content.find("--gtest_filter="), 0u); |
| base::ReplaceSubstringsAfterOffset(&content, 0, "--gtest_filter=", ""); |
| std::vector<std::string> gtest_filter_tests = |
| SplitString(content, ":", TRIM_WHITESPACE, SPLIT_WANT_ALL); |
| ASSERT_EQ(gtest_filter_tests.size(), test_names.size()); |
| for (unsigned i = 0; i < test_names.size(); i++) { |
| EXPECT_EQ(gtest_filter_tests.at(i), test_names.at(i)); |
| } |
| } |
| |
| // Verify that a result watcher can stop polling early when all tests complete. |
| TEST_F(ResultWatcherTest, PollCompletesQuickly) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\" />\n", |
| " <testcase name=\"B\" status=\"run\" time=\"0.500\" " |
| "classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\">\n", " </testcase>\n", |
| " <x-teststart name=\"C\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now() + Milliseconds(500)).c_str(), "\" />\n", |
| " <testcase name=\"C\" status=\"run\" time=\"0.500\" " |
| "classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now() + Milliseconds(500)).c_str(), "\">\n", |
| " </testcase>\n", " </testsuite>\n", "</testsuites>\n"}))); |
| |
| MockResultWatcher result_watcher(result_file, 2); |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .WillOnce(DoAll(InvokeWithoutArgs([&]() { |
| task_environment.AdvanceClock(Milliseconds(1500)); |
| }), |
| Return(true))); |
| |
| Time start = Time::Now(); |
| ASSERT_TRUE(result_watcher.PollUntilDone(Seconds(45))); |
| ASSERT_EQ(Time::Now() - start, Milliseconds(1500)); |
| } |
| |
| // Verify that a result watcher repeatedly checks the file for a batch of slow |
| // tests. Each test completes in 40s, which is just under the timeout of 45s. |
| TEST_F(ResultWatcherTest, PollCompletesSlowly) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\" />\n"}))); |
| |
| MockResultWatcher result_watcher(result_file, 10); |
| size_t checks = 0; |
| bool done = false; |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .Times(10) |
| .WillRepeatedly( |
| DoAll(Invoke([&](TimeDelta timeout) { |
| task_environment.AdvanceClock(timeout); |
| // Append a result with "time" (duration) as 40.000s and |
| // "timestamp" (test start) as `Now()` - 45s. |
| AppendToFile( |
| result_file, |
| StrCat({" <testcase name=\"B\" status=\"run\" " |
| "time=\"40.000\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now() - Seconds(45)).c_str(), |
| "\">\n", " </testcase>\n"})); |
| checks++; |
| if (checks == 10) { |
| AppendToFile(result_file, |
| " </testsuite>\n" |
| "</testsuites>\n"); |
| done = true; |
| } else { |
| // Append a preliminary result for the next test that |
| // started when the last test completed (i.e., `Now()` - 45s |
| // + 40s). |
| AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" " |
| "timestamp=\"", |
| TimeToISO8601(Time::Now() - Seconds(5)).c_str(), |
| "\" />\n"})); |
| } |
| }), |
| ReturnPointee(&done))); |
| |
| Time start = Time::Now(); |
| ASSERT_TRUE(result_watcher.PollUntilDone(Seconds(45))); |
| // The first check occurs 45s after the batch starts, so the sequence of |
| // events looks like: |
| // 00:00 - Test 1 starts |
| // 00:40 - Test 1 completes, test 2 starts |
| // 00:45 - Check 1 occurs |
| // 01:20 - Test 2 completes, test 3 starts |
| // 01:25 - Check 2 occurs |
| // 02:00 - Test 3 completes, test 4 starts |
| // 02:05 - Check 3 occurs |
| // ... |
| ASSERT_EQ(Time::Now() - start, Seconds(45 + 40 * 9)); |
| } |
| |
| // Verify that the result watcher identifies when a test times out. |
| TEST_F(ResultWatcherTest, PollTimeout) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\" />\n"}))); |
| |
| MockResultWatcher result_watcher(result_file, 10); |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .Times(2) |
| .WillRepeatedly( |
| DoAll(Invoke(&task_environment, &test::TaskEnvironment::AdvanceClock), |
| Return(false))); |
| |
| Time start = Time::Now(); |
| ASSERT_FALSE(result_watcher.PollUntilDone(Seconds(45))); |
| // Include a small grace period. |
| ASSERT_EQ(Time::Now() - start, Seconds(45) + TestTimeouts::tiny_timeout()); |
| } |
| |
| // Verify that the result watcher retries incomplete reads. |
| TEST_F(ResultWatcherTest, RetryIncompleteResultRead) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| // Opening "<summary>" tag is not closed. |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\" />\n", |
| " <testcase name=\"B\" status=\"run\" time=\"40.000\" " |
| "classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\">\n", |
| " <summary>"}))); |
| |
| MockResultWatcher result_watcher(result_file, 2); |
| size_t attempts = 0; |
| bool done = false; |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .Times(5) |
| .WillRepeatedly(DoAll(Invoke([&](TimeDelta timeout) { |
| task_environment.AdvanceClock(timeout); |
| // Don't bother writing the rest of the file when |
| // this test completes. |
| done = ++attempts >= 5; |
| }), |
| ReturnPointee(&done))); |
| |
| Time start = Time::Now(); |
| ASSERT_TRUE(result_watcher.PollUntilDone(Seconds(45))); |
| ASSERT_EQ(Time::Now() - start, |
| Seconds(45) + 4 * TestTimeouts::tiny_timeout()); |
| } |
| |
| // Verify that the result watcher continues polling with the base timeout when |
| // the clock jumps backward. |
| TEST_F(ResultWatcherTest, PollWithClockJumpBackward) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| // Cannot move the mock time source backward, so write future timestamps into |
| // the result file instead. |
| Time time_before_change = Time::Now() + Hours(1); |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(time_before_change).c_str(), "\" />\n", |
| " <testcase name=\"B\" status=\"run\" time=\"0.500\" " |
| "classname=\"A\" timestamp=\"", |
| TimeToISO8601(time_before_change).c_str(), "\">\n", |
| " </testcase>\n", |
| " <x-teststart name=\"C\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(time_before_change + Milliseconds(500)).c_str(), |
| "\" />\n"}))); |
| |
| MockResultWatcher result_watcher(result_file, 2); |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .WillOnce( |
| DoAll(Invoke(&task_environment, &test::TaskEnvironment::AdvanceClock), |
| Return(false))) |
| .WillOnce( |
| DoAll(Invoke(&task_environment, &test::TaskEnvironment::AdvanceClock), |
| Return(true))); |
| |
| Time start = Time::Now(); |
| ASSERT_TRUE(result_watcher.PollUntilDone(Seconds(45))); |
| ASSERT_EQ(Time::Now() - start, Seconds(90)); |
| } |
| |
| // Verify that the result watcher continues polling with the base timeout when |
| // the clock jumps forward. |
| TEST_F(ResultWatcherTest, PollWithClockJumpForward) { |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath result_file = CreateResultFile(); |
| ASSERT_TRUE(AppendToFile( |
| result_file, |
| StrCat({" <x-teststart name=\"B\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\" />\n", |
| " <testcase name=\"B\" status=\"run\" time=\"0.500\" " |
| "classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now()).c_str(), "\">\n", " </testcase>\n", |
| " <x-teststart name=\"C\" classname=\"A\" timestamp=\"", |
| TimeToISO8601(Time::Now() + Milliseconds(500)).c_str(), |
| "\" />\n"}))); |
| task_environment.AdvanceClock(Hours(1)); |
| |
| MockResultWatcher result_watcher(result_file, 2); |
| EXPECT_CALL(result_watcher, WaitWithTimeout(_)) |
| .WillOnce( |
| DoAll(Invoke(&task_environment, &test::TaskEnvironment::AdvanceClock), |
| Return(false))) |
| .WillOnce( |
| DoAll(Invoke(&task_environment, &test::TaskEnvironment::AdvanceClock), |
| Return(true))); |
| |
| Time start = Time::Now(); |
| ASSERT_TRUE(result_watcher.PollUntilDone(Seconds(45))); |
| ASSERT_EQ(Time::Now() - start, Seconds(90)); |
| } |
| |
| // Validate delegate sets batch size correctly. |
| TEST_F(UnitTestLauncherDelegateTester, BatchSize) { |
| UnitTestLauncherDelegate launcher_delegate(&defaultPlatform, 15u, true, |
| DoNothing()); |
| TestLauncherDelegate* delegate_ptr = &launcher_delegate; |
| EXPECT_EQ(delegate_ptr->GetBatchSize(), 15u); |
| } |
| |
| // The following 4 tests are disabled as they are meant to only run from |
| // |RunMockTests| to validate tests launcher output for known results. The tests |
| // are expected to run in order within a same batch. |
| |
| // Basic test to pass |
| TEST(MockUnitTests, DISABLED_PassTest) { |
| ASSERT_TRUE(true); |
| } |
| // Basic test to fail |
| TEST(MockUnitTests, DISABLED_FailTest) { |
| ASSERT_TRUE(false); |
| } |
| // Basic test to crash |
| TEST(MockUnitTests, DISABLED_CrashTest) { |
| ImmediateCrash(); |
| } |
| // Basic test will not be reached, due to the preceding crash in the same batch. |
| TEST(MockUnitTests, DISABLED_NoRunTest) { |
| ASSERT_TRUE(true); |
| } |
| |
| // Using TestLauncher to launch 3 basic unitests |
| // and validate the resulting json file. |
| TEST_F(UnitTestLauncherDelegateTester, RunMockTests) { |
| CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram()); |
| command_line.AppendSwitchASCII("gtest_filter", "MockUnitTests.DISABLED_*"); |
| |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath path = dir.GetPath().AppendASCII("SaveSummaryResult.json"); |
| command_line.AppendSwitchPath("test-launcher-summary-output", path); |
| command_line.AppendSwitch("gtest_also_run_disabled_tests"); |
| command_line.AppendSwitchASCII("test-launcher-retry-limit", "0"); |
| |
| std::string output; |
| GetAppOutputAndError(command_line, &output); |
| |
| // Validate the resulting JSON file is the expected output. |
| absl::optional<Value::Dict> root = test_launcher_utils::ReadSummary(path); |
| ASSERT_TRUE(root); |
| |
| const Value::Dict* dict = root->FindDict("test_locations"); |
| ASSERT_TRUE(dict); |
| EXPECT_EQ(4u, dict->size()); |
| |
| EXPECT_TRUE( |
| test_launcher_utils::ValidateTestLocations(*dict, "MockUnitTests")); |
| |
| const Value::List* list = root->FindList("per_iteration_data"); |
| ASSERT_TRUE(list); |
| ASSERT_EQ(1u, list->size()); |
| |
| const Value::Dict* iteration_dict = (*list)[0].GetIfDict(); |
| ASSERT_TRUE(iteration_dict); |
| EXPECT_EQ(4u, iteration_dict->size()); |
| // We expect the result to be stripped of disabled prefix. |
| EXPECT_TRUE(test_launcher_utils::ValidateTestResult( |
| *iteration_dict, "MockUnitTests.PassTest", "SUCCESS", 0u)); |
| EXPECT_TRUE(test_launcher_utils::ValidateTestResult( |
| *iteration_dict, "MockUnitTests.FailTest", "FAILURE", 1u)); |
| EXPECT_TRUE(test_launcher_utils::ValidateTestResult( |
| *iteration_dict, "MockUnitTests.CrashTest", "CRASH", 0u)); |
| EXPECT_TRUE(test_launcher_utils::ValidateTestResult( |
| *iteration_dict, "MockUnitTests.NoRunTest", "NOTRUN", 0u, |
| /*have_running_info=*/false)); |
| } |
| |
| TEST(ProcessGTestOutputTest, RunMockTests) { |
| ScopedTempDir dir; |
| CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram()); |
| command_line.AppendSwitchASCII("gtest_filter", "MockUnitTests.DISABLED_*"); |
| |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath path = dir.GetPath().AppendASCII("SaveSummaryResult.xml"); |
| command_line.AppendSwitchPath("test-launcher-output", path); |
| command_line.AppendSwitch("gtest_also_run_disabled_tests"); |
| command_line.AppendSwitch("single-process-tests"); |
| |
| std::string output; |
| GetAppOutputAndError(command_line, &output); |
| |
| std::vector<TestResult> test_results; |
| bool crashed = false; |
| bool have_test_results = ProcessGTestOutput(path, &test_results, &crashed); |
| |
| EXPECT_TRUE(have_test_results); |
| EXPECT_TRUE(crashed); |
| ASSERT_EQ(test_results.size(), 3u); |
| |
| EXPECT_EQ(test_results[0].full_name, "MockUnitTests.DISABLED_PassTest"); |
| EXPECT_EQ(test_results[0].status, TestResult::TEST_SUCCESS); |
| EXPECT_EQ(test_results[0].test_result_parts.size(), 0u); |
| ASSERT_TRUE(test_results[0].timestamp.has_value()); |
| EXPECT_GT(*test_results[0].timestamp, Time()); |
| EXPECT_FALSE(test_results[0].thread_id); |
| EXPECT_FALSE(test_results[0].process_num); |
| |
| EXPECT_EQ(test_results[1].full_name, "MockUnitTests.DISABLED_FailTest"); |
| EXPECT_EQ(test_results[1].status, TestResult::TEST_FAILURE); |
| EXPECT_EQ(test_results[1].test_result_parts.size(), 1u); |
| ASSERT_TRUE(test_results[1].timestamp.has_value()); |
| EXPECT_GT(*test_results[1].timestamp, Time()); |
| |
| EXPECT_EQ(test_results[2].full_name, "MockUnitTests.DISABLED_CrashTest"); |
| EXPECT_EQ(test_results[2].status, TestResult::TEST_CRASH); |
| EXPECT_EQ(test_results[2].test_result_parts.size(), 0u); |
| ASSERT_TRUE(test_results[2].timestamp.has_value()); |
| EXPECT_GT(*test_results[2].timestamp, Time()); |
| } |
| |
| // TODO(crbug.com/1094369): Enable leaked-child checks on other platforms. |
| #if BUILDFLAG(IS_FUCHSIA) |
| |
| // Test that leaves a child process running. The test is DISABLED_, so it can |
| // be launched explicitly by RunMockLeakProcessTest |
| |
| MULTIPROCESS_TEST_MAIN(LeakChildProcess) { |
| while (true) |
| PlatformThread::Sleep(base::Seconds(1)); |
| } |
| |
| TEST(LeakedChildProcessTest, DISABLED_LeakChildProcess) { |
| Process child_process = SpawnMultiProcessTestChild( |
| "LeakChildProcess", GetMultiProcessTestChildBaseCommandLine(), |
| LaunchOptions()); |
| ASSERT_TRUE(child_process.IsValid()); |
| // Don't wait for the child process to exit. |
| } |
| |
| // Validate that a test that leaks a process causes the batch to have an |
| // error exit_code. |
| TEST_F(UnitTestLauncherDelegateTester, LeakedChildProcess) { |
| CommandLine command_line(CommandLine::ForCurrentProcess()->GetProgram()); |
| command_line.AppendSwitchASCII( |
| "gtest_filter", "LeakedChildProcessTest.DISABLED_LeakChildProcess"); |
| |
| ASSERT_TRUE(dir.CreateUniqueTempDir()); |
| FilePath path = dir.GetPath().AppendASCII("SaveSummaryResult.json"); |
| command_line.AppendSwitchPath("test-launcher-summary-output", path); |
| command_line.AppendSwitch("gtest_also_run_disabled_tests"); |
| command_line.AppendSwitchASCII("test-launcher-retry-limit", "0"); |
| |
| std::string output; |
| int exit_code = 0; |
| GetAppOutputWithExitCode(command_line, &output, &exit_code); |
| |
| // Validate that we actually ran a test. |
| absl::optional<Value::Dict> root = test_launcher_utils::ReadSummary(path); |
| ASSERT_TRUE(root); |
| |
| Value::Dict* dict = root->FindDict("test_locations"); |
| ASSERT_TRUE(dict); |
| EXPECT_EQ(1u, dict->size()); |
| |
| EXPECT_TRUE(test_launcher_utils::ValidateTestLocations( |
| *dict, "LeakedChildProcessTest")); |
| |
| // Validate that the leaked child caused the batch to error-out. |
| EXPECT_EQ(exit_code, 1); |
| } |
| #endif // BUILDFLAG(IS_FUCHSIA) |
| |
| // Validate GetTestOutputSnippetTest assigns correct output snippet. |
| TEST(TestLauncherTools, GetTestOutputSnippetTest) { |
| const std::string output = |
| "[ RUN ] TestCase.FirstTest\n" |
| "[ OK ] TestCase.FirstTest (0 ms)\n" |
| "Post first test output\n" |
| "[ RUN ] TestCase.SecondTest\n" |
| "[ FAILED ] TestCase.SecondTest (0 ms)\n" |
| "[ RUN ] TestCase.ThirdTest\n" |
| "[ SKIPPED ] TestCase.ThirdTest (0 ms)\n" |
| "Post second test output"; |
| TestResult result; |
| |
| // test snippet of a successful test |
| result.full_name = "TestCase.FirstTest"; |
| result.status = TestResult::TEST_SUCCESS; |
| EXPECT_EQ(GetTestOutputSnippet(result, output), |
| "[ RUN ] TestCase.FirstTest\n" |
| "[ OK ] TestCase.FirstTest (0 ms)\n"); |
| |
| // test snippet of a failure on exit tests should include output |
| // after test concluded, but not subsequent tests output. |
| result.status = TestResult::TEST_FAILURE_ON_EXIT; |
| EXPECT_EQ(GetTestOutputSnippet(result, output), |
| "[ RUN ] TestCase.FirstTest\n" |
| "[ OK ] TestCase.FirstTest (0 ms)\n" |
| "Post first test output\n"); |
| |
| // test snippet of a failed test |
| result.full_name = "TestCase.SecondTest"; |
| result.status = TestResult::TEST_FAILURE; |
| EXPECT_EQ(GetTestOutputSnippet(result, output), |
| "[ RUN ] TestCase.SecondTest\n" |
| "[ FAILED ] TestCase.SecondTest (0 ms)\n"); |
| |
| // test snippet of a skipped test. Note that the status is SUCCESS because |
| // the gtest XML format doesn't make a difference between SUCCESS and SKIPPED |
| result.full_name = "TestCase.ThirdTest"; |
| result.status = TestResult::TEST_SUCCESS; |
| EXPECT_EQ(GetTestOutputSnippet(result, output), |
| "[ RUN ] TestCase.ThirdTest\n" |
| "[ SKIPPED ] TestCase.ThirdTest (0 ms)\n"); |
| } |
| |
| MATCHER(CheckTruncationPreservesMessage, "") { |
| // Ensure the inserted message matches the expected pattern. |
| constexpr char kExpected[] = R"(FATAL.*message\n)"; |
| EXPECT_THAT(arg, ::testing::ContainsRegex(kExpected)); |
| |
| const std::string snippet = |
| base::StrCat({"[ RUN ] SampleTestSuite.SampleTestName\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n", |
| arg, |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n" |
| "Padding log message added for testing purposes\n"}); |
| |
| // Strip the stack trace off the end of message. |
| size_t line_end_pos = arg.find("\n"); |
| std::string first_line = arg.substr(0, line_end_pos + 1); |
| |
| const std::string result = TruncateSnippetFocused(snippet, 300); |
| EXPECT_TRUE(result.find(first_line) > 0); |
| EXPECT_EQ(result.length(), 300UL); |
| return true; |
| } |
| |
| void MatchesFatalMessagesTest() { |
| // Different Chrome test suites have different settings for their logs. |
| // E.g. unit tests may not show the process ID (as they are single process), |
| // whereas browser tests usually do (as they are multi-process). This |
| // affects how log messages are formatted and hence how the log criticality |
| // i.e. "FATAL", appears in the log message. We test the two extremes -- |
| // all process IDs, timestamps present, and all not present. We also test |
| // the presence/absence of an extra logging prefix. |
| { |
| // Process ID, Thread ID, Timestamp and Tickcount. |
| logging::SetLogItems(true, true, true, true); |
| logging::SetLogPrefix(nullptr); |
| EXPECT_DEATH_IF_SUPPORTED(LOG(FATAL) << "message", |
| CheckTruncationPreservesMessage()); |
| } |
| { |
| logging::SetLogItems(false, false, false, false); |
| logging::SetLogPrefix(nullptr); |
| EXPECT_DEATH_IF_SUPPORTED(LOG(FATAL) << "message", |
| CheckTruncationPreservesMessage()); |
| } |
| { |
| // Process ID, Thread ID, Timestamp and Tickcount. |
| logging::SetLogItems(true, true, true, true); |
| logging::SetLogPrefix("mylogprefix"); |
| EXPECT_DEATH_IF_SUPPORTED(LOG(FATAL) << "message", |
| CheckTruncationPreservesMessage()); |
| } |
| { |
| logging::SetLogItems(false, false, false, false); |
| logging::SetLogPrefix("mylogprefix"); |
| EXPECT_DEATH_IF_SUPPORTED(LOG(FATAL) << "message", |
| CheckTruncationPreservesMessage()); |
| } |
| } |
| |
| // Validates TestSnippetFocused correctly identifies fatal messages to |
| // retain during truncation. |
| TEST(TestLauncherTools, TruncateSnippetFocusedMatchesFatalMessagesTest) { |
| logging::ScopedLoggingSettings scoped_logging_settings; |
| #if BUILDFLAG(IS_CHROMEOS_ASH) |
| scoped_logging_settings.SetLogFormat(logging::LogFormat::LOG_FORMAT_SYSLOG); |
| #endif |
| MatchesFatalMessagesTest(); |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS_ASH) |
| // Validates TestSnippetFocused correctly identifies fatal messages to |
| // retain during truncation, for ChromeOS Ash. |
| TEST(TestLauncherTools, TruncateSnippetFocusedMatchesFatalMessagesCrosAshTest) { |
| logging::ScopedLoggingSettings scoped_logging_settings; |
| scoped_logging_settings.SetLogFormat(logging::LogFormat::LOG_FORMAT_CHROME); |
| MatchesFatalMessagesTest(); |
| } |
| #endif |
| |
| // Validate TestSnippetFocused truncates snippets correctly, regardless of |
| // whether fatal messages appear at the start, middle or end of the snippet. |
| TEST(TestLauncherTools, TruncateSnippetFocusedTest) { |
| // Test where FATAL message appears in the start of the log. |
| const std::string snippet = |
| "[ RUN ] " |
| "EndToEndTests/" |
| "EndToEndTest.WebTransportSessionUnidirectionalStreamSentEarly/" |
| "draft29_QBIC\n" |
| "[26219:26368:FATAL:tls_handshaker.cc(293)] 1-RTT secret(s) not set " |
| "yet.\n" |
| "#0 0x55619ad1fcdb in backtrace " |
| "/b/s/w/ir/cache/builder/src/third_party/llvm/compiler-rt/lib/asan/../" |
| "sanitizer_common/sanitizer_common_interceptors.inc:4205:13\n" |
| "#1 0x5561a6bdf519 in base::debug::CollectStackTrace(void**, unsigned " |
| "long) ./../../base/debug/stack_trace_posix.cc:845:39\n" |
| "#2 0x5561a69a1293 in StackTrace " |
| "./../../base/debug/stack_trace.cc:200:12\n" |
| "...\n"; |
| const std::string result = TruncateSnippetFocused(snippet, 300); |
| EXPECT_EQ( |
| result, |
| "[ RUN ] EndToEndTests/EndToEndTest.WebTransportSessionUnidirection" |
| "alStreamSentEarly/draft29_QBIC\n" |
| "[26219:26368:FATAL:tls_handshaker.cc(293)] 1-RTT secret(s) not set " |
| "yet.\n" |
| "#0 0x55619ad1fcdb in backtrace /b/s/w/ir/cache/bui\n" |
| "<truncated (358 bytes)>\n" |
| "Trace ./../../base/debug/stack_trace.cc:200:12\n" |
| "...\n"); |
| EXPECT_EQ(result.length(), 300UL); |
| |
| // Test where FATAL message appears in the middle of the log. |
| const std::string snippet_two = |
| "[ RUN ] NetworkingPrivateApiTest.CreateSharedNetwork\n" |
| "Padding log information added for testing purposes\n" |
| "Padding log information added for testing purposes\n" |
| "Padding log information added for testing purposes\n" |
| "FATAL extensions_unittests[12666:12666]: [managed_network_configuration" |
| "_handler_impl.cc(525)] Check failed: !guid_str && !guid_str->empty().\n" |
| "#0 0x562f31dba779 base::debug::CollectStackTrace()\n" |
| "#1 0x562f31cdf2a3 base::debug::StackTrace::StackTrace()\n" |
| "#2 0x562f31cf4380 logging::LogMessage::~LogMessage()\n" |
| "#3 0x562f31cf4d3e logging::LogMessage::~LogMessage()\n"; |
| const std::string result_two = TruncateSnippetFocused(snippet_two, 300); |
| EXPECT_EQ( |
| result_two, |
| "[ RUN ] NetworkingPriv\n" |
| "<truncated (210 bytes)>\n" |
| " added for testing purposes\n" |
| "FATAL extensions_unittests[12666:12666]: [managed_network_configuration" |
| "_handler_impl.cc(525)] Check failed: !guid_str && !guid_str->empty().\n" |
| "#0 0x562f31dba779 base::deb\n" |
| "<truncated (213 bytes)>\n" |
| ":LogMessage::~LogMessage()\n"); |
| EXPECT_EQ(result_two.length(), 300UL); |
| |
| // Test where FATAL message appears at end of the log. |
| const std::string snippet_three = |
| "[ RUN ] All/PDFExtensionAccessibilityTreeDumpTest.Highlights/" |
| "linux\n" |
| "[6741:6741:0716/171816.818448:ERROR:power_monitor_device_source_stub.cc" |
| "(11)] Not implemented reached in virtual bool base::PowerMonitorDevice" |
| "Source::IsOnBatteryPower()\n" |
| "[6741:6741:0716/171816.818912:INFO:content_main_runner_impl.cc(1082)]" |
| " Chrome is running in full browser mode.\n" |
| "libva error: va_getDriverName() failed with unknown libva error,driver" |
| "_name=(null)\n" |
| "[6741:6741:0716/171817.688633:FATAL:agent_scheduling_group_host.cc(290)" |
| "] Check failed: message->routing_id() != MSG_ROUTING_CONTROL " |
| "(2147483647 vs. 2147483647)\n"; |
| const std::string result_three = TruncateSnippetFocused(snippet_three, 300); |
| EXPECT_EQ( |
| result_three, |
| "[ RUN ] All/PDFExtensionAccessibilityTreeDumpTest.Hi\n" |
| "<truncated (432 bytes)>\n" |
| "Name() failed with unknown libva error,driver_name=(null)\n" |
| "[6741:6741:0716/171817.688633:FATAL:agent_scheduling_group_host.cc(290)" |
| "] Check failed: message->routing_id() != MSG_ROUTING_CONTROL " |
| "(2147483647 vs. 2147483647)\n"); |
| EXPECT_EQ(result_three.length(), 300UL); |
| |
| // Test where FATAL message does not appear. |
| const std::string snippet_four = |
| "[ RUN ] All/PassingTest/linux\n" |
| "Padding log line 1 added for testing purposes\n" |
| "Padding log line 2 added for testing purposes\n" |
| "Padding log line 3 added for testing purposes\n" |
| "Padding log line 4 added for testing purposes\n" |
| "Padding log line 5 added for testing purposes\n" |
| "Padding log line 6 added for testing purposes\n"; |
| const std::string result_four = TruncateSnippetFocused(snippet_four, 300); |
| EXPECT_EQ(result_four, |
| "[ RUN ] All/PassingTest/linux\n" |
| "Padding log line 1 added for testing purposes\n" |
| "Padding log line 2 added for testing purposes\n" |
| "Padding lo\n<truncated (311 bytes)>\n" |
| "Padding log line 4 added for testing purposes\n" |
| "Padding log line 5 added for testing purposes\n" |
| "Padding log line 6 added for testing purposes\n"); |
| EXPECT_EQ(result_four.length(), 300UL); |
| } |
| |
| } // namespace |
| |
| } // namespace base |
