use std::fmt::Write as _;
pub struct Suite {
pub file: String,
pub duration_ms: f64,
pub error: Option<Error>,
pub cases: Vec<Case>,
}
pub struct Error {
pub message: String,
pub kind: &'static str,
pub body: String,
}
pub struct Case {
pub name: String,
pub ms: f64,
pub failure: Option<String>,
}
fn secs(ms: f64) -> String {
format!("{:.3}", ms / 1000.0)
}
fn sanitize(c: char) -> Option<char> {
match c {
'\t' | '\n' | '\r' => Some(c),
c if (c as u32) < 0x20 => Some('\u{fffd}'),
c => Some(c),
}
}
pub fn text(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars().filter_map(sanitize) {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
c => out.push(c),
}
}
out
}
pub fn attr(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars().filter_map(sanitize) {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
'\n' => out.push_str(" "),
'\r' => out.push_str(" "),
'\t' => out.push_str("	"),
c => out.push(c),
}
}
out
}
fn headline(s: &str) -> &str {
s.lines().next().unwrap_or_default()
}
pub fn document(suites: &[Suite], run_ms: f64) -> String {
let tests: usize = suites.iter().map(|s| s.cases.len()).sum();
let failures: usize = suites
.iter()
.map(|s| s.cases.iter().filter(|c| c.failure.is_some()).count())
.sum();
let errors = suites.iter().filter(|s| s.error.is_some()).count();
let mut out = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
let _ = writeln!(
out,
"<testsuites name=\"htl test\" tests=\"{tests}\" failures=\"{failures}\" errors=\"{errors}\" skipped=\"0\" time=\"{}\">",
secs(run_ms)
);
for s in suites {
let s_failures = s.cases.iter().filter(|c| c.failure.is_some()).count();
let _ = writeln!(
out,
" <testsuite name=\"{}\" tests=\"{}\" failures=\"{s_failures}\" errors=\"{}\" skipped=\"0\" time=\"{}\">",
attr(&s.file),
s.cases.len(),
usize::from(s.error.is_some()),
secs(s.duration_ms)
);
if let Some(e) = &s.error {
let _ = writeln!(
out,
" <error message=\"{}\" type=\"{}\">{}</error>",
attr(headline(&e.message)),
e.kind,
text(&e.body)
);
}
for c in &s.cases {
let head = format!(
" <testcase classname=\"{}\" name=\"{}\" time=\"{}\"",
attr(&s.file),
attr(&c.name),
secs(c.ms)
);
match &c.failure {
None => {
let _ = writeln!(out, "{head}/>");
}
Some(m) => {
let _ = writeln!(out, "{head}>");
let _ = writeln!(
out,
" <failure message=\"{}\" type=\"failure\">{}</failure>",
attr(headline(m)),
text(m)
);
let _ = writeln!(out, " </testcase>");
}
}
}
let _ = writeln!(out, " </testsuite>");
}
out.push_str("</testsuites>\n");
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn markup_in_a_message_survives_as_data() {
let doc = document(
&[Suite {
file: "tests/a_test.tl".into(),
duration_ms: 12.0,
error: None,
cases: vec![Case {
name: "a > b".into(),
ms: 1.0,
failure: Some("expected <p> & \"q\" got 'r'\nstack traceback:\n\tin fn".into()),
}],
}],
13.0,
);
assert!(
doc.contains("message=\"expected <p> & "q" got 'r'\"")
);
assert!(doc.contains("expected <p> & \"q\" got 'r'\nstack traceback:"));
assert!(doc.contains("tests=\"1\" failures=\"1\" errors=\"0\""));
}
#[test]
fn a_newline_in_an_attribute_is_a_character_reference() {
assert_eq!(attr("a\nb"), "a b");
assert_eq!(text("a\nb"), "a\nb");
}
}