| // Copyright 2023 The Fuchsia Authors. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use std::iter::Peekable; |
| |
| use crate::helpers::TestType; |
| use anyhow::{anyhow, Error}; |
| use gtest_runner_lib::parser::{ |
| Failure, IndividualTestOutput, IndividualTestOutputStatus, TestOutput, TestSuiteOutput, |
| }; |
| use xml::reader::{EventReader, XmlEvent}; |
| |
| pub fn parse_results(test_type: TestType, contents: &str) -> Result<TestOutput, Error> { |
| match test_type { |
| TestType::Gtest | TestType::Gunit => { |
| serde_json::from_str(contents).map_err(|e| anyhow!("JSON parsing error: {e}")) |
| } |
| TestType::GtestXmlOutput => { |
| let mut errors = vec![]; |
| let mut iter = EventReader::new(contents.as_bytes()) |
| .into_iter() |
| .filter(|p| match p { |
| Ok(XmlEvent::Whitespace(..)) => false, |
| _ => true, |
| }) |
| .map_while(|r| match r { |
| Ok(event) => Some(event), |
| Err(err) => { |
| errors.push(err); |
| None |
| } |
| }) |
| .peekable(); |
| parse_xml_test_output(&mut iter) |
| .map_err(|e| anyhow!("Parsing error: {e} errors from XML parser: {errors:?}")) |
| } |
| _ => panic!("Do not know how to parse results for test type."), |
| } |
| } |
| |
| fn parse_xml_test_output<I>(iter: &mut Peekable<I>) -> Result<TestOutput, Error> |
| where |
| I: Iterator<Item = XmlEvent>, |
| { |
| match iter.next() { |
| Some(XmlEvent::StartDocument { .. }) => {} |
| _ => { |
| return Err(anyhow!("Expected document start event")); |
| } |
| } |
| if let Some(XmlEvent::StartElement { name, .. }) = iter.next() { |
| if name.borrow().local_name != "testsuites" { |
| return Err(anyhow!("Expected <testsuites> saw ${name}")); |
| } |
| |
| Ok(TestOutput { testsuites: parse_xml_testsuites(iter)? }) |
| } else { |
| Err(anyhow!("Expected <testsuites>")) |
| } |
| } |
| |
| fn parse_xml_testsuites<I>(iter: &mut Peekable<I>) -> Result<Vec<TestSuiteOutput>, Error> |
| where |
| I: Iterator<Item = XmlEvent>, |
| { |
| let mut suites = vec![]; |
| loop { |
| if let Some(XmlEvent::StartElement { name, attributes, .. }) = iter.next() { |
| if name.borrow().local_name != "testsuite" { |
| return Err(anyhow!("Expected <testsuite> got {name}")); |
| } |
| let mut output = TestSuiteOutput::default(); |
| for a in attributes { |
| match a.name.local_name.as_str() { |
| "name" => { |
| output.name = a.value.to_string(); |
| } |
| "tests" => { |
| output.tests = a |
| .value |
| .parse::<usize>() |
| .map_err(|e| anyhow!("Unable to parse number of tests: {e}"))?; |
| } |
| "failures" => { |
| output.failures = a |
| .value |
| .parse::<usize>() |
| .map_err(|e| anyhow!("Unable to parse number of failures: {e}"))?; |
| } |
| "time" => { |
| output.time = a.value.to_string(); |
| } |
| _ => {} |
| } |
| } |
| output.testsuite = parse_xml_testsuite(iter)?; |
| suites.push(output); |
| } else { |
| return Ok(suites); |
| } |
| } |
| } |
| |
| fn parse_xml_testsuite<I>(iter: &mut Peekable<I>) -> Result<Vec<IndividualTestOutput>, Error> |
| where |
| I: Iterator<Item = XmlEvent>, |
| { |
| let mut outputs = vec![]; |
| loop { |
| match iter.peek() { |
| Some(XmlEvent::StartElement { .. }) => { |
| outputs.push(parse_xml_testcase(iter)?); |
| } |
| Some(XmlEvent::EndElement { .. }) => { |
| iter.next(); |
| break; |
| } |
| _ => { |
| return Err(anyhow!("Expected <testcase> or </testsuite>")); |
| } |
| } |
| } |
| Ok(outputs) |
| } |
| |
| fn parse_xml_testcase<I>(iter: &mut Peekable<I>) -> Result<IndividualTestOutput, Error> |
| where |
| I: Iterator<Item = XmlEvent>, |
| { |
| if let Some(XmlEvent::StartElement { name, attributes, .. }) = iter.next() { |
| if name.local_name != "testcase" { |
| return Err(anyhow!("Expected <testcase> saw {name}")); |
| } |
| |
| let mut output = IndividualTestOutput::default(); |
| |
| // The XML format does not include a "result" field. Pretend that it's completed. |
| output.result = "COMPLETED".to_string(); |
| |
| for a in attributes { |
| match a.name.local_name.as_str() { |
| "name" => { |
| output.name = a.value.to_string(); |
| } |
| "time" => { |
| output.time = a.value.to_string(); |
| } |
| "status" => { |
| output.status = match a.value.as_str() { |
| "run" => IndividualTestOutputStatus::Run, |
| _ => IndividualTestOutputStatus::NotRun, |
| } |
| } |
| _ => {} |
| } |
| } |
| loop { |
| match iter.peek() { |
| Some(XmlEvent::EndElement { .. }) => { |
| iter.next(); |
| break; |
| } |
| Some(XmlEvent::StartElement { .. }) => { |
| output.failures = Some(parse_xml_failures(iter)?); |
| } |
| _ => { |
| return Err(anyhow!("Expected <failure> or end of <testcase>")); |
| } |
| } |
| } |
| Ok(output) |
| } else { |
| Err(anyhow!("Expected <testcase>")) |
| } |
| } |
| |
| fn parse_xml_failures<I>(iter: &mut Peekable<I>) -> Result<Vec<Failure>, Error> |
| where |
| I: Iterator<Item = XmlEvent>, |
| { |
| let mut failures = vec![]; |
| loop { |
| if let Some(XmlEvent::StartElement { name, attributes, .. }) = iter.peek() { |
| if name.local_name.as_str() != "failure" { |
| return Err(anyhow!("Expected <failure> got {name}")); |
| } |
| let mut failure = Failure::default(); |
| for a in attributes { |
| if a.name.local_name == "message" { |
| failure.failure = a.value.to_string(); |
| } |
| } |
| iter.next(); |
| if let Some(XmlEvent::EndElement { .. }) = iter.next() { |
| failures.push(failure); |
| } else { |
| return Err(anyhow!("Expected </failure>")); |
| } |
| } else { |
| break; |
| } |
| } |
| Ok(failures) |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use crate::helpers::TestType; |
| use gtest_runner_lib::parser::*; |
| |
| use super::parse_results; |
| |
| fn expected_results() -> TestOutput { |
| TestOutput { |
| testsuites: vec![ |
| TestSuiteOutput { |
| name: "MathTest".to_string(), |
| tests: 2, |
| failures: 1, |
| disabled: 0, |
| time: "0.015s".to_string(), |
| testsuite: vec![ |
| IndividualTestOutput { |
| name: "Addition".to_string(), |
| status: IndividualTestOutputStatus::Run, |
| time: "0.007s".to_string(), |
| failures: Some(vec![ |
| Failure { |
| failure: "Value of: add(1, 1)\n Actual: 3\n Expected: 2" |
| .to_string(), |
| }, |
| Failure { |
| failure: "Value of: add(1, -1)\n Actual: 1\n Expected: 0" |
| .to_string(), |
| }, |
| ]), |
| result: "COMPLETED".to_string(), |
| }, |
| IndividualTestOutput { |
| name: "Subtraction".to_string(), |
| status: IndividualTestOutputStatus::Run, |
| time: "0.005s".to_string(), |
| failures: None, |
| result: "COMPLETED".to_string(), |
| }, |
| ], |
| }, |
| TestSuiteOutput { |
| name: "LogicTest".to_string(), |
| tests: 1, |
| failures: 0, |
| disabled: 0, |
| time: "0.005s".to_string(), |
| testsuite: vec![IndividualTestOutput { |
| name: "NonContradiction".to_string(), |
| status: IndividualTestOutputStatus::Run, |
| time: "0.005s".to_string(), |
| failures: None, |
| result: "COMPLETED".to_string(), |
| }], |
| }, |
| ], |
| } |
| } |
| |
| #[test] |
| fn parse_json_results() { |
| let results_json = r#" |
| { |
| "tests": 3, |
| "failures": 1, |
| "disabled": 0, |
| "errors": 0, |
| "time": "0.035s", |
| "timestamp": "2011-10-31T18:52:42Z", |
| "name": "AllTests", |
| "testsuites": [ |
| { |
| "name": "MathTest", |
| "tests": 2, |
| "failures": 1, |
| "disabled": 0, |
| "errors": 0, |
| "time": "0.015s", |
| "testsuite": [ |
| { |
| "name": "Addition", |
| "status": "RUN", |
| "result": "COMPLETED", |
| "time": "0.007s", |
| "classname": "", |
| "failures": [ |
| { |
| "failure": "Value of: add(1, 1)\n Actual: 3\n Expected: 2", |
| "type": "" |
| }, |
| { |
| "failure": "Value of: add(1, -1)\n Actual: 1\n Expected: 0", |
| "type": "" |
| } |
| ] |
| }, |
| { |
| "name": "Subtraction", |
| "status": "RUN", |
| "result": "COMPLETED", |
| "time": "0.005s", |
| "classname": "" |
| } |
| ] |
| }, |
| { |
| "name": "LogicTest", |
| "tests": 1, |
| "failures": 0, |
| "disabled": 0, |
| "errors": 0, |
| "time": "0.005s", |
| "testsuite": [ |
| { |
| "name": "NonContradiction", |
| "status": "RUN", |
| "result": "COMPLETED", |
| "time": "0.005s", |
| "classname": "" |
| } |
| ] |
| } |
| ] |
| } |
| "#; |
| |
| let results = parse_results(TestType::Gtest, results_json).unwrap(); |
| assert_eq!(results, expected_results()); |
| } |
| |
| #[test] |
| fn parse_xml_results() { |
| let results_xml = r#" |
| <?xml version="1.0" encoding="UTF-8"?> |
| <testsuites name="AllTests" tests="3" failures="1" disabled="0" errors="0" |
| timestamp="2011-10-31T18:52:42Z"> |
| <testsuite name="MathTest" tests="2" failures="1" disabled="0" errors="0" time="0.015s"> |
| <testcase name="Addition" status="run" time="0.007s" classname="addition"> |
| <failure message="Value of: add(1, 1) |
| Actual: 3 |
| Expected: 2" type=""></failure> |
| <failure message="Value of: add(1, -1) |
| Actual: 1 |
| Expected: 0" type=""></failure> |
| </testcase> |
| <testcase name="Subtraction" status="run" time="0.005s" classname="subtraction" /> |
| </testsuite> |
| <testsuite name="LogicTest" tests="1" failures="0" disabled="0" errors="0" time="0.005s"> |
| <testcase name="NonContradiction" status="run" time="0.005s" classname="logic_test" /> |
| </testsuite> |
| </testsuites> |
| "#; |
| |
| let results = parse_results(TestType::GtestXmlOutput, results_xml).unwrap(); |
| assert_eq!(results, expected_results()); |
| } |
| } |
