| // Copyright 2026 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use std::borrow::Cow; |
| use std::sync::LazyLock; |
| use std::time::Duration; |
| |
| use regex::Regex; |
| |
| use crate::schema::{FailureReason, TestCaseResult, TestStatus}; |
| |
| static ANSI_ESCAPE_PATTERN: LazyLock<Regex> = |
| LazyLock::new(|| Regex::new(r"\x1b\[[0-9;]*[a-zA-Z]").unwrap()); |
| |
| /// Matches log timestamp prefixes in square brackets to strip them before parsing. |
| /// Supported formats include: |
| /// - Elapsed seconds with decimal precision (e.g. `[ 12.345 ]`, `[00012.100]`) |
| /// - Clock time (e.g. `[ 12:34:56.789 ]`, `[12:34:56]`) |
| /// - ISO 8601 timestamps (e.g. `[ 2026-08-28T12:34:56Z ]`, `[2026-08-28 12:34:56.789]`) |
| static TIMESTAMP_PREFIX_PATTERN: LazyLock<Regex> = LazyLock::new(|| { |
| Regex::new( |
| r"^\s*\[\s*(?:\d+\.\d+|\d{1,2}:\d{2}(?::\d{2})?(?:\.\d+)?|\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)\s*\]\s*", |
| ) |
| .unwrap() |
| }); |
| |
| static GTEST_RUN_PATTERN: LazyLock<Regex> = |
| LazyLock::new(|| Regex::new(r"^\[\s*RUN\s*\]\s*(\S+?)\.(\S+)$").unwrap()); |
| |
| static GTEST_COMPLETION_PATTERN: LazyLock<Regex> = LazyLock::new(|| { |
| Regex::new(r"^\[\s*(OK|FAILED|SKIPPED|DISABLED)\s*\]\s*(\S+?)\.(\S+?)(?:\s*\((\d+)\s*ms\))?$") |
| .unwrap() |
| }); |
| |
| const LEGACY_TEST_STDOUT_PREFIX: &str = "[stdout - legacy_test]"; |
| const GTEST_FORMAT_NAME: &str = "GoogleTest"; |
| |
| fn sanitize_line<'a>(raw_line: &'a str) -> Cow<'a, str> { |
| let after_ansi = ANSI_ESCAPE_PATTERN.replace_all(raw_line, ""); |
| match TIMESTAMP_PREFIX_PATTERN.replace_all(&after_ansi, "") { |
| Cow::Borrowed(_) => after_ansi, |
| Cow::Owned(s) => Cow::Owned(s), |
| } |
| } |
| |
| /// Parses stdout from a GoogleTest program (or serial stream) and returns structured results. |
| pub fn parse(stdout: &[u8]) -> Vec<TestCaseResult> { |
| parse_str(&String::from_utf8_lossy(stdout)) |
| } |
| |
| /// Parses stdout string from a GoogleTest program and returns structured results. |
| pub fn parse_str(stdout: &str) -> Vec<TestCaseResult> { |
| let mut results = Vec::new(); |
| let mut current_suite = String::new(); |
| let mut current_case = String::new(); |
| let mut output_for_case = Vec::new(); |
| |
| let flush_unfinished_test = |results: &mut Vec<TestCaseResult>, |
| suite: &mut String, |
| case: &mut String, |
| output: &mut Vec<String>| { |
| if !case.is_empty() { |
| let display_name = format!("{suite}.{case}"); |
| let failure_reason = if !output.is_empty() { |
| FailureReason::from_message(&output.join("\n")) |
| } else { |
| None |
| }; |
| results.push(TestCaseResult { |
| display_name, |
| suite_name: std::mem::take(suite), |
| case_name: std::mem::take(case), |
| status: TestStatus::Fail, |
| duration: Duration::ZERO, |
| format: GTEST_FORMAT_NAME.to_string(), |
| failure_reason, |
| output_files: None, |
| output_dir: None, |
| }); |
| output.clear(); |
| } |
| }; |
| |
| for raw_line in stdout.lines() { |
| let line = sanitize_line(raw_line); |
| let trimmed_line = line.trim(); |
| |
| if trimmed_line.starts_with('[') { |
| if let Some(captures) = GTEST_RUN_PATTERN.captures(trimmed_line) { |
| flush_unfinished_test( |
| &mut results, |
| &mut current_suite, |
| &mut current_case, |
| &mut output_for_case, |
| ); |
| current_suite = captures[1].to_string(); |
| current_case = captures[2].to_string(); |
| output_for_case.clear(); |
| continue; |
| } |
| |
| if let Some(captures) = GTEST_COMPLETION_PATTERN.captures(trimmed_line) { |
| let duration_match = captures.get(4); |
| let has_duration = duration_match.is_some(); |
| let is_disabled = &captures[1] == "DISABLED"; |
| |
| if current_case.is_empty() && !has_duration && !is_disabled { |
| continue; |
| } |
| |
| if is_disabled { |
| flush_unfinished_test( |
| &mut results, |
| &mut current_suite, |
| &mut current_case, |
| &mut output_for_case, |
| ); |
| } |
| |
| let status = match &captures[1] { |
| "OK" => TestStatus::Pass, |
| "FAILED" => TestStatus::Fail, |
| "SKIPPED" | "DISABLED" => TestStatus::Skip, |
| _ => TestStatus::Fail, |
| }; |
| |
| let suite_name = captures[2].to_string(); |
| let case_name = captures[3].to_string(); |
| let display_name = format!("{suite_name}.{case_name}"); |
| |
| let duration = duration_match |
| .and_then(|m| m.as_str().parse::<u64>().ok()) |
| .map(Duration::from_millis) |
| .unwrap_or(Duration::ZERO); |
| |
| let failure_reason = if status.is_failure() && !output_for_case.is_empty() { |
| FailureReason::from_message(&output_for_case.join("\n")) |
| } else { |
| None |
| }; |
| |
| results.push(TestCaseResult { |
| display_name, |
| suite_name, |
| case_name, |
| status, |
| duration, |
| format: GTEST_FORMAT_NAME.to_string(), |
| failure_reason, |
| output_files: None, |
| output_dir: None, |
| }); |
| |
| current_suite.clear(); |
| current_case.clear(); |
| output_for_case.clear(); |
| continue; |
| } |
| } |
| |
| if !current_case.is_empty() && !trimmed_line.starts_with(LEGACY_TEST_STDOUT_PREFIX) { |
| output_for_case.push(line.into_owned()); |
| } |
| } |
| |
| flush_unfinished_test( |
| &mut results, |
| &mut current_suite, |
| &mut current_case, |
| &mut output_for_case, |
| ); |
| |
| results |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| fn assert_parsed_cases(stdout: &str, expected: Vec<TestCaseResult>) { |
| let results = parse(stdout.as_bytes()); |
| assert_eq!(results, expected); |
| } |
| |
| #[test] |
| fn test_parse_empty() { |
| assert_parsed_cases("", vec![]); |
| } |
| |
| #[test] |
| fn test_parse_no_test_cases() { |
| assert_parsed_cases("non-test output without any markers", vec![]); |
| } |
| |
| #[test] |
| fn test_parse_google_test() { |
| let stdout = r#" |
| Sometimes there is weird stuff in stdout. |
| [==========] Running 4 tests from 1 test suite. |
| [----------] Global test environment set-up. |
| [----------] 4 tests from ChannelTest |
| [ RUN ] ChannelTest.ReadWrite |
| [ OK ] ChannelTest.ReadWrite (4 ms) |
| [ RUN ] ChannelTest.InvalidHandle |
| ../../src/zircon/tests/channel_test.cc:45: Failure |
| Expected equality of these values: |
| status |
| Which is: ZX_ERR_BAD_HANDLE (-11) |
| ZX_OK |
| Which is: 0 |
| [ FAILED ] ChannelTest.InvalidHandle (5 ms) |
| [ RUN ] ChannelTest.InterleavedLogs |
| Sometimes tests print to stdout. |
| Their prints get interleaved with the results. |
| [ OK ] ChannelTest.InterleavedLogs (3 ms) |
| [ RUN ] ChannelTest.SkipFeature |
| [ SKIPPED ] ChannelTest.SkipFeature (1 ms) |
| [----------] 4 tests from ChannelTest (13 ms total) |
| [----------] Global test environment tear-down |
| [==========] 4 tests from 1 test suite ran. (15 ms total) |
| [ PASSED ] 2 tests. |
| [ SKIPPED ] 1 test. |
| [ FAILED ] 1 test. |
| "#; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "ChannelTest.ReadWrite".to_string(), |
| suite_name: "ChannelTest".to_string(), |
| case_name: "ReadWrite".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(4), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "ChannelTest.InvalidHandle".to_string(), |
| suite_name: "ChannelTest".to_string(), |
| case_name: "InvalidHandle".to_string(), |
| status: TestStatus::Fail, |
| duration: Duration::from_millis(5), |
| format: "GoogleTest".to_string(), |
| failure_reason: FailureReason::from_message( |
| "../../src/zircon/tests/channel_test.cc:45: Failure\nExpected equality of these values:\n status\n Which is: ZX_ERR_BAD_HANDLE (-11)\n ZX_OK\n Which is: 0", |
| ), |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "ChannelTest.InterleavedLogs".to_string(), |
| suite_name: "ChannelTest".to_string(), |
| case_name: "InterleavedLogs".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(3), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "ChannelTest.SkipFeature".to_string(), |
| suite_name: "ChannelTest".to_string(), |
| case_name: "SkipFeature".to_string(), |
| status: TestStatus::Skip, |
| duration: Duration::from_millis(1), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_serial_google_test() { |
| let stdout = "\n[00012.100] [==========] Running 2 tests from 1 test suite.\n\ |
| [00012.105] [----------] Global test environment set-up.\n\ |
| [00012.110] [----------] 2 tests from SerialTest\n\ |
| [00012.120] \x1b[0;32m[ RUN ]\x1b[m SerialTest.PassTest\n\ |
| [00012.125] \x1b[0;32m[ OK ]\x1b[m SerialTest.PassTest (5 ms)\n\ |
| [00012.130] \x1b[0;31m[ RUN ]\x1b[m SerialTest.FailTest\n\ |
| [00012.135] assertion failed: expected 42 but got 0\n\ |
| [00012.140] \x1b[0;31m[ FAILED ]\x1b[m SerialTest.FailTest (10 ms)\n\ |
| [00012.145] [----------] 2 tests from SerialTest (15 ms total)\n\ |
| [00012.150] [==========] 2 tests ran.\n"; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "SerialTest.PassTest".to_string(), |
| suite_name: "SerialTest".to_string(), |
| case_name: "PassTest".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(5), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "SerialTest.FailTest".to_string(), |
| suite_name: "SerialTest".to_string(), |
| case_name: "FailTest".to_string(), |
| status: TestStatus::Fail, |
| duration: Duration::from_millis(10), |
| format: "GoogleTest".to_string(), |
| failure_reason: FailureReason::from_message( |
| "assertion failed: expected 42 but got 0", |
| ), |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_disabled_google_test() { |
| let stdout = r#" |
| [==========] Running 3 tests from 1 test suite. |
| [----------] 3 tests from DisabledSuite |
| [ DISABLED ] DisabledSuite.FeatureOff |
| [ RUN ] DisabledSuite.FeatureActive |
| [ OK ] DisabledSuite.FeatureActive (8 ms) |
| [ DISABLED ] DisabledSuite.AnotherOff |
| [----------] 3 tests from DisabledSuite (8 ms total) |
| "#; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "DisabledSuite.FeatureOff".to_string(), |
| suite_name: "DisabledSuite".to_string(), |
| case_name: "FeatureOff".to_string(), |
| status: TestStatus::Skip, |
| duration: Duration::ZERO, |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "DisabledSuite.FeatureActive".to_string(), |
| suite_name: "DisabledSuite".to_string(), |
| case_name: "FeatureActive".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(8), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "DisabledSuite.AnotherOff".to_string(), |
| suite_name: "DisabledSuite".to_string(), |
| case_name: "AnotherOff".to_string(), |
| status: TestStatus::Skip, |
| duration: Duration::ZERO, |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_flexible_timestamps() { |
| let stdout = r#" |
| [2026-08-28 03:47:19.123] [==========] Running 2 tests from 1 test suite. |
| [2026-08-28 03:47:19.124] [ RUN ] TimeSuite.IsoTest |
| [2026-08-28 03:47:19.129] [ OK ] TimeSuite.IsoTest (5 ms) |
| [12:34:56.789] [ RUN ] TimeSuite.ClockTest |
| [12:34:56.790] [ OK ] TimeSuite.ClockTest (1 ms) |
| "#; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "TimeSuite.IsoTest".to_string(), |
| suite_name: "TimeSuite".to_string(), |
| case_name: "IsoTest".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(5), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "TimeSuite.ClockTest".to_string(), |
| suite_name: "TimeSuite".to_string(), |
| case_name: "ClockTest".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(1), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_parameterized_google_test() { |
| let stdout = r#" |
| [==========] Running 2 tests from 1 test suite. |
| [----------] 2 tests from SocketSuite/ParamTest |
| [ RUN ] SocketSuite/ParamTest.DataTransfer/0 |
| [ OK ] SocketSuite/ParamTest.DataTransfer/0 (12 ms) |
| [ RUN ] SocketSuite/ParamTest.DataTransfer/1 |
| [ OK ] SocketSuite/ParamTest.DataTransfer/1 (11 ms) |
| [----------] 2 tests from SocketSuite/ParamTest (23 ms total) |
| "#; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "SocketSuite/ParamTest.DataTransfer/0".to_string(), |
| suite_name: "SocketSuite/ParamTest".to_string(), |
| case_name: "DataTransfer/0".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(12), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "SocketSuite/ParamTest.DataTransfer/1".to_string(), |
| suite_name: "SocketSuite/ParamTest".to_string(), |
| case_name: "DataTransfer/1".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(11), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_crash_google_test() { |
| let stdout = r#" |
| [==========] Running 2 tests from 1 test suite. |
| [----------] 2 tests from CrashSuite |
| [ RUN ] CrashSuite.TestPass |
| [ OK ] CrashSuite.TestPass (2 ms) |
| [ RUN ] CrashSuite.TestCrash |
| kernel panic: segmentation fault at 0xdeadbeef |
| {{{bt:0:0x123456}}} |
| "#; |
| |
| let expected = vec![ |
| TestCaseResult { |
| display_name: "CrashSuite.TestPass".to_string(), |
| suite_name: "CrashSuite".to_string(), |
| case_name: "TestPass".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(2), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }, |
| TestCaseResult { |
| display_name: "CrashSuite.TestCrash".to_string(), |
| suite_name: "CrashSuite".to_string(), |
| case_name: "TestCrash".to_string(), |
| status: TestStatus::Fail, |
| duration: Duration::ZERO, |
| format: "GoogleTest".to_string(), |
| failure_reason: FailureReason::from_message( |
| "kernel panic: segmentation fault at 0xdeadbeef\n{{{bt:0:0x123456}}}", |
| ), |
| output_files: None, |
| output_dir: None, |
| }, |
| ]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| |
| #[test] |
| fn test_parse_bracketed_non_timestamp_logs() { |
| let stdout = r#" |
| [==========] Running 1 test from 1 test suite. |
| [----------] 1 test from BracketSuite |
| [ RUN ] BracketSuite.BracketTest |
| [0] array element value |
| [1/5] progress step |
| [42] answer |
| [ OK ] BracketSuite.BracketTest (3 ms) |
| [----------] 1 test from BracketSuite (3 ms total) |
| "#; |
| |
| let expected = vec![TestCaseResult { |
| display_name: "BracketSuite.BracketTest".to_string(), |
| suite_name: "BracketSuite".to_string(), |
| case_name: "BracketTest".to_string(), |
| status: TestStatus::Pass, |
| duration: Duration::from_millis(3), |
| format: "GoogleTest".to_string(), |
| failure_reason: None, |
| output_files: None, |
| output_dir: None, |
| }]; |
| |
| assert_parsed_cases(stdout, expected); |
| } |
| } |
