use super::compare::CORRECT_COLUMN;
use super::flow::Header;
use super::model::{OutputColumn, ReportResult, ReportRow, Verdict};
use super::writer::ReportWriter;
use std::collections::{HashMap, HashSet};
const MAX_CELL: usize = 1000;
pub struct JunitWriter;
impl ReportWriter for JunitWriter {
fn write(&self, result: &ReportResult, header: &Header) -> Result<Vec<u8>, String> {
let columns = result.resolved_columns(header);
let suite = suite_name(header);
let mut cases: Vec<Case> = result
.rows
.iter()
.enumerate()
.map(|(r, row)| Case::of(r, row, result, &columns))
.collect();
let explained =
|e: &String| !result.dry_run && result.rows.iter().any(|row| row.errors.contains(e));
let unexplained: Vec<&String> = result.errors.iter().filter(|e| !explained(e)).collect();
let mut notes: Vec<String> = Vec::new();
if result.dry_run {
notes.push("DRY RUN: no requests were sent — these cases are projected".to_string());
}
if let Some(p) = &result.partial {
notes.push(format!(
"PARTIAL: the run was stopped — {} of {} rows ran",
p.rows_completed, p.rows_planned
));
}
notes.extend(result.skipped.iter().map(|s| format!("skipped: {s}")));
notes.extend(result.warnings.iter().map(|w| format!("warning: {w}")));
let run_case = (!unexplained.is_empty() || !notes.is_empty()).then(|| Case {
name: suite.clone(),
errors: unexplained.iter().map(|e| (*e).clone()).collect(),
failures: Vec::new(),
context: notes.iter().map(|n| (String::new(), n.clone())).collect(),
seconds: 0.0,
disc: String::new(),
});
let run_index = run_case.is_some().then_some(cases.len());
cases.extend(run_case);
disambiguate(&mut cases);
let projected = |i: usize| result.dry_run && Some(i) != run_index;
let tests = cases.len();
let (mut failures, mut errors, mut skipped) = (0, 0, 0);
for (i, c) in cases.iter().enumerate() {
match c.status(projected(i)) {
Status::Skipped => skipped += 1,
Status::Error => errors += 1,
Status::Failure => failures += 1,
Status::Passed => {}
}
}
let time = positive(cases.iter().map(|c| c.seconds).sum());
let mut out = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
out.push_str(&format!(
"<testsuites name=\"{}\" tests=\"{tests}\" failures=\"{failures}\" \
errors=\"{errors}\" skipped=\"{skipped}\" time=\"{time:.3}\">\n",
esc(&suite)
));
out.push_str(&format!(
" <testsuite name=\"{}\" tests=\"{tests}\" failures=\"{failures}\" \
errors=\"{errors}\" skipped=\"{skipped}\" time=\"{time:.3}\">\n",
esc(&suite)
));
for (i, case) in cases.iter().enumerate() {
push_case(&mut out, case, &suite, projected(i));
}
if !notes.is_empty() {
out.push_str(&format!(
" <system-err>{}</system-err>\n",
esc(¬es.join("\n"))
));
}
out.push_str(" </testsuite>\n</testsuites>\n");
Ok(out.into_bytes())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Status {
Skipped,
Error,
Failure,
Passed,
}
struct Case {
name: String,
errors: Vec<String>,
failures: Vec<String>,
context: Vec<(String, String)>,
seconds: f64,
disc: String,
}
impl Case {
fn of(r: usize, row: &ReportRow, result: &ReportResult, columns: &[OutputColumn]) -> Self {
let errors = row.errors.clone();
let mut failures = Vec::new();
for col in columns.iter().filter(|c| c.truth.is_some()) {
if result.verdicts.get(&(r, col.header.clone())) == Some(&Verdict::Incorrect) {
let expected = result
.truths
.get(&(r, col.header.clone()))
.cloned()
.unwrap_or_default();
let got = col.value(row, &result.no_match_marker);
failures.push(format!(
"{}: expected {expected:?}, got {got:?}",
col.header
));
}
}
if failures.is_empty()
&& row.cells.get(CORRECT_COLUMN).map(String::as_str)
== Some(Verdict::Incorrect.as_str())
{
failures.push("the row's answer did not match its ground truth".to_string());
}
let ms = result.row_duration_ms(row);
let context = columns
.iter()
.map(|c| {
(
c.header.clone(),
truncate(&c.value(row, &result.no_match_marker)),
)
})
.filter(|(_, v)| !v.is_empty())
.collect();
Self {
name: case_name(r, row),
errors,
failures,
context,
seconds: positive(ms / 1000.0),
disc: discriminator(row),
}
}
fn status(&self, dry_run: bool) -> Status {
if dry_run {
Status::Skipped
} else if !self.errors.is_empty() {
Status::Error
} else if !self.failures.is_empty() {
Status::Failure
} else {
Status::Passed
}
}
}
fn discriminator(row: &ReportRow) -> String {
let parts: Vec<&str> = [row.target.as_deref(), row.comparison.as_deref()]
.into_iter()
.flatten()
.filter(|p| !p.is_empty())
.collect();
parts.join(" ")
}
fn disambiguate(cases: &mut [Case]) {
let mut counts: HashMap<String, usize> = HashMap::new();
for c in cases.iter() {
*counts.entry(seen_as(&c.name)).or_default() += 1;
}
let mut taken: HashSet<String> = counts
.iter()
.filter(|(_, n)| **n == 1)
.map(|(name, _)| name.clone())
.collect();
if taken.len() == cases.len() {
return;
}
let mut nth: HashMap<String, usize> = HashMap::new();
for c in cases.iter_mut() {
let canon = seen_as(&c.name);
if counts[&canon] == 1 {
continue;
}
let n = nth.entry(canon).or_default();
let mut candidate = if c.disc.is_empty() {
*n += 1;
format!("{} #{n}", c.name)
} else {
format!("{} #{}", c.name, c.disc)
};
while !taken.insert(seen_as(&candidate)) {
*n += 1;
candidate = format!("{} #{n}", c.name);
}
c.name = candidate;
}
}
fn seen_as(name: &str) -> String {
esc(name)
.chars()
.map(|c| {
if matches!(c, '\t' | '\n' | '\r') {
' '
} else {
c
}
})
.collect()
}
fn positive(v: f64) -> f64 {
v + 0.0
}
fn case_name(r: usize, row: &ReportRow) -> String {
let mut name = row.key.join(" / ");
if name.trim().is_empty() {
name = format!("row {}", r + 1);
}
match &row.target {
Some(t) if !t.is_empty() => format!("{name} [{t}]"),
_ => name,
}
}
fn suite_name(header: &Header) -> String {
match header.get("name").map(str::trim) {
Some(n) if !n.is_empty() => n.to_string(),
_ => "PaperTrail report".to_string(),
}
}
fn push_case(out: &mut String, case: &Case, suite: &str, dry_run: bool) {
out.push_str(&format!(
" <testcase name=\"{}\" classname=\"{}\" time=\"{:.3}\"",
esc(&case.name),
esc(suite),
case.seconds
));
let status = case.status(dry_run);
let mut out_lines: Vec<String> = Vec::new();
if status == Status::Error {
out_lines.extend(case.failures.iter().cloned());
}
if status == Status::Skipped {
out_lines.extend(case.errors.iter().cloned());
}
out_lines.extend(case.context.iter().map(|(k, v)| {
if k.is_empty() {
v.clone()
} else {
format!("{k}: {v}")
}
}));
if status == Status::Passed && out_lines.is_empty() {
out.push_str("/>\n");
return;
}
out.push_str(">\n");
match status {
Status::Skipped => {
out.push_str(" <skipped message=\"dry run — no request was sent\"/>\n");
}
Status::Error => {
for e in &case.errors {
out.push_str(&format!(
" <error message=\"{}\" type=\"request\">{}</error>\n",
esc(&first_line(e)),
esc(e)
));
}
}
Status::Failure => {
for f in &case.failures {
out.push_str(&format!(
" <failure message=\"{}\" type=\"truth\">{}</failure>\n",
esc(&first_line(f)),
esc(f)
));
}
}
Status::Passed => {}
}
if !out_lines.is_empty() {
out.push_str(&format!(
" <system-out>{}</system-out>\n",
esc(&out_lines.join("\n"))
));
}
out.push_str(" </testcase>\n");
}
fn first_line(s: &str) -> String {
truncate(s.lines().next().unwrap_or("").trim())
}
fn truncate(s: &str) -> String {
if s.chars().count() <= MAX_CELL {
return s.to_string();
}
let kept: String = s.chars().take(MAX_CELL).collect();
format!("{kept}…")
}
fn esc(s: &str) -> String {
let mut out = String::with_capacity(s.len());
for c in s.chars() {
match c {
'&' => out.push_str("&"),
'<' => out.push_str("<"),
'>' => out.push_str(">"),
'"' => out.push_str("""),
'\'' => out.push_str("'"),
'\t' | '\n' | '\r' => out.push(c),
c if is_xml_char(c) => out.push(c),
_ => out.push(' '),
}
}
out
}
fn is_xml_char(c: char) -> bool {
let u = c as u32;
(0x20..=0xD7FF).contains(&u)
|| (0xE000..=0xFFFD).contains(&u)
|| (0x10000..=0x10FFFF).contains(&u)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::report::model::{ReportResult, ReportRow};
use std::collections::HashMap;
fn row(key: &[&str], cells: &[(&str, &str)]) -> ReportRow {
ReportRow {
errors: Vec::new(),
role: crate::report::model::RowRole::default(),
cells: cells
.iter()
.map(|(k, v)| (k.to_string(), v.to_string()))
.collect(),
vars: HashMap::new(),
key: key.iter().map(|k| k.to_string()).collect(),
path: Vec::new(),
comparison: None,
target: None,
}
}
fn failed_row(key: &[&str], cells: &[(&str, &str)], errors: &[&str]) -> ReportRow {
ReportRow {
errors: errors.iter().map(|e| e.to_string()).collect(),
..row(key, cells)
}
}
fn xml(result: &ReportResult) -> String {
String::from_utf8(JunitWriter.write(result, &Header::default()).unwrap()).unwrap()
}
#[test]
fn a_failed_request_is_an_error_case() {
let res = ReportResult {
column_order: vec!["Ping.HttpStatus".into(), "Ping.Error".into()],
rows: vec![
row(&["a"], &[("Ping.HttpStatus", "200"), ("Ping.Error", "")]),
failed_row(
&["b"],
&[
("Ping.HttpStatus", "500"),
("Ping.Error", "Expected status 200 but got 500"),
],
&["Ping: Expected status 200 but got 500"],
),
],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("tests=\"2\""), "{out}");
assert!(out.contains("errors=\"1\""), "{out}");
assert!(out.contains("failures=\"0\""), "{out}");
assert!(
out.contains("name=\"b\"") && out.contains("but got 500"),
"the failing case is named by its key: {out}"
);
}
#[test]
fn a_wrong_answer_is_a_failure_with_both_sides_of_the_comparison() {
let mut res = ReportResult {
column_order: vec!["Verdict".into()],
rows: vec![row(&["doc-1"], &[("Verdict", "fake")])],
column_truths: [("Verdict".to_string(), "real".to_string())]
.into_iter()
.collect(),
..Default::default()
};
res.verdicts
.insert((0, "Verdict".into()), Verdict::Incorrect);
res.truths.insert((0, "Verdict".into()), "real".into());
let out = xml(&res);
assert!(out.contains("failures=\"1\""), "{out}");
assert!(out.contains("errors=\"0\""), "{out}");
assert!(
out.contains("expected \\\"real\\\"") || out.contains("expected "real""),
"the message carries what was expected: {out}"
);
assert!(
out.contains("got "fake""),
"and what came back: {out}"
);
}
#[test]
fn a_dry_run_skips_every_case_rather_than_passing_it() {
let res = ReportResult {
column_order: vec!["Ping.HttpStatus".into()],
rows: vec![row(&["a"], &[("Ping.HttpStatus", "")])],
dry_run: true,
..Default::default()
};
let out = xml(&res);
assert!(out.contains("skipped=\"1\""), "{out}");
assert!(out.contains("<skipped"), "{out}");
assert!(out.contains("DRY RUN"), "the suite says why: {out}");
}
#[test]
fn a_dry_run_that_could_not_resolve_a_request_is_not_a_clean_skip() {
let err = "request 'ghost' could not be resolved";
let res = ReportResult {
column_order: vec!["ghost.Error".into()],
rows: vec![failed_row(
&["a"],
&[("ghost.Error", "unresolved request 'ghost'")],
&[err],
)],
errors: vec![err.to_string()],
dry_run: true,
..Default::default()
};
let out = xml(&res);
assert!(out.contains("errors=\"1\""), "the suite reports it: {out}");
assert!(out.contains("<error"), "as an error element: {out}");
let quoted = esc(err);
assert!(
out.contains("ed),
"quoting the run's own wording: {out}"
);
assert!(out.contains("<skipped"), "{out}");
assert!(out.contains("skipped=\"1\""), "{out}");
assert!(
out.matches(quoted.as_str()).count() >= 2,
"the skipped case attributes it too: {out}"
);
}
#[test]
fn a_run_error_that_belongs_to_no_row_still_fails_the_suite() {
let res = ReportResult {
errors: vec!["FILES \"cases/*.json\" matched nothing".into()],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("tests=\"1\""), "{out}");
assert!(out.contains("errors=\"1\""), "{out}");
assert!(out.contains("matched nothing"), "{out}");
}
#[test]
fn a_partial_run_carries_its_caveat_on_the_suite() {
let res = ReportResult {
rows: vec![row(&["a"], &[("Ping.HttpStatus", "200")])],
partial: Some(crate::report::model::Partial {
rows_completed: 1,
rows_planned: 9,
}),
..Default::default()
};
let out = xml(&res);
assert!(out.contains("PARTIAL"), "{out}");
assert!(out.contains("1 of 9"), "{out}");
}
#[test]
fn control_characters_and_markup_cannot_break_the_document() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![row(
&["<script>"],
&[("Body", "a\u{0}b & <tag> \"quoted\"")],
)],
..Default::default()
};
let out = xml(&res);
assert!(!out.contains('\u{0}'), "the NUL is gone: {out:?}");
assert!(out.contains("<script>"), "{out}");
assert!(out.contains("&"), "{out}");
assert!(!out.contains("<tag>"), "no raw markup from a body: {out}");
}
#[test]
fn a_row_with_no_timing_takes_no_time_rather_than_negative_time() {
let res = ReportResult {
column_order: vec!["Ping.status".into()],
rows: vec![row(&["a"], &[("Ping.status", "200")])],
..Default::default()
};
let out = xml(&res);
assert!(!out.contains("-0.000"), "no negative durations: {out}");
assert!(out.contains("time=\"0.000\""), "{out}");
}
#[test]
fn every_document_this_writer_produces_parses_as_xml() {
let awkward = ReportResult {
column_order: vec!["Body".into(), "Ping.Time".into()],
rows: vec![
failed_row(
&["odd \u{fffe}\u{ffff}\u{0}\u{1b}"],
&[("Body", "]]> & <b> \"q\" '\u{7f}'"), ("Ping.Time", "12")],
&["Ping: broken \u{ffff} pipe"],
),
row(&["dup"], &[("Body", "one")]),
row(&["dup"], &[("Body", "two")]),
row(&[], &[("Body", "")]),
],
errors: vec!["FILES \"x\" matched <nothing>".into()],
warnings: vec!["CLEANUP failed & kept going".into()],
skipped: vec!["Teardown".into()],
..Default::default()
};
let header = Header {
lines: vec![crate::report::flow::HeaderLine::Directive {
key: "name".into(),
value: "A & B <report>".into(),
}],
};
for (what, result, head) in [
("awkward", awkward, header),
("empty", ReportResult::default(), Header::default()),
(
"dry run",
ReportResult {
rows: vec![row(&["a"], &[("Ping.HttpStatus", "")])],
dry_run: true,
errors: vec!["never sent".into()],
..Default::default()
},
Header::default(),
),
] {
let doc = String::from_utf8(JunitWriter.write(&result, &head).unwrap()).unwrap();
let mut reader = quick_xml::Reader::from_str(&doc);
let mut depth = 0i32;
loop {
match reader.read_event() {
Ok(quick_xml::events::Event::Start(_)) => depth += 1,
Ok(quick_xml::events::Event::End(_)) => depth -= 1,
Ok(quick_xml::events::Event::Eof) => break,
Ok(_) => {}
Err(e) => panic!("the {what} document is not XML: {e}\n{doc}"),
}
}
assert_eq!(
depth, 0,
"unbalanced elements in the {what} document:\n{doc}"
);
for illegal in ['\u{0}', '\u{1b}', '\u{fffe}', '\u{ffff}'] {
assert!(
!doc.contains(illegal),
"{illegal:?} survived into the {what} document"
);
}
}
}
#[test]
fn colliding_row_keys_become_separate_cases() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![
row(&["same"], &[("Body", "first")]),
failed_row(&["same"], &[("Body", "second")], &["Ping: down"]),
row(&["other"], &[("Body", "third")]),
],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("name=\"same #1\""), "{out}");
assert!(out.contains("name=\"same #2\""), "{out}");
assert!(out.contains("name=\"other\""), "{out}");
assert!(out.contains("errors=\"1\""), "{out}");
}
fn names(out: &str) -> Vec<String> {
out.match_indices("<testcase name=\"")
.map(|(i, m)| {
let rest = &out[i + m.len()..];
rest[..rest.find('"').unwrap()]
.chars()
.map(|c| {
if matches!(c, '\t' | '\n' | '\r') {
' '
} else {
c
}
})
.collect()
})
.collect()
}
fn all_unique(out: &str) -> bool {
let n = names(out);
let mut sorted = n.clone();
sorted.sort();
sorted.dedup();
sorted.len() == n.len()
}
#[test]
fn a_name_invented_to_resolve_a_collision_cannot_make_another() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![
row(&["same"], &[("Body", "first")]),
row(&["same"], &[("Body", "second")]),
row(&["same #1"], &[("Body", "third")]),
],
..Default::default()
};
let out = xml(&res);
assert!(all_unique(&out), "{out}");
assert_eq!(names(&out).len(), 3, "{out}");
}
#[test]
fn a_row_named_like_the_suite_cannot_swallow_the_runs_own_case() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![row(&[&suite_name(&Header::default())], &[("Body", "a")])],
errors: vec!["FILES \"cases/*.json\" matched nothing".into()],
..Default::default()
};
let out = xml(&res);
assert!(all_unique(&out), "{out}");
assert!(out.contains("<error"), "the run error survives: {out}");
}
#[test]
fn names_that_only_a_parser_would_flatten_together_are_still_told_apart() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![
row(&["a\tb"], &[("Body", "tab")]),
row(&["a b"], &[("Body", "space")]),
row(&["a\u{0}c"], &[("Body", "nul")]),
row(&["a c"], &[("Body", "space too")]),
],
..Default::default()
};
let out = xml(&res);
assert!(all_unique(&out), "{out}");
}
#[test]
fn a_collision_is_named_for_what_actually_differs() {
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![
ReportRow {
comparison: Some("nightly".into()),
..row(&["same"], &[("Body", "a")])
},
ReportRow {
comparison: Some("release".into()),
..row(&["same"], &[("Body", "b")])
},
],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("name=\"same #nightly\""), "{out}");
assert!(out.contains("name=\"same #release\""), "{out}");
}
#[test]
fn a_hidden_error_column_still_fails_its_case() {
let res = ReportResult {
column_order: vec!["Ping.HttpStatus".into()],
rows: vec![failed_row(
&["a"],
&[("Ping.HttpStatus", "500")],
&["Ping: Expected status 200 but got 500"],
)],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("errors=\"1\""), "{out}");
assert!(out.contains("but got 500"), "{out}");
assert_eq!(out.matches("<testcase").count(), 1, "{out}");
assert_eq!(out.matches("<error").count(), 1, "{out}");
}
#[test]
fn a_rows_error_is_not_also_reported_against_the_run() {
let res = ReportResult {
column_order: vec!["Ping.HttpStatus".into()],
rows: vec![failed_row(
&["a"],
&[("Ping.HttpStatus", "500")],
&["Ping: connection refused".to_string().as_str()],
)],
errors: vec!["Ping: connection refused".into()],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("tests=\"1\""), "one case, not two: {out}");
assert!(out.contains("errors=\"1\""), "{out}");
}
#[test]
fn a_failed_request_outranks_its_wrong_answer() {
let mut res = ReportResult {
column_order: vec!["Ping.status".into()],
rows: vec![failed_row(
&["a"],
&[
("Ping.status", "500"),
(crate::report::compare::CORRECT_COLUMN, "incorrect"),
],
&["Ping: Expected status 200 but got 500"],
)],
..Default::default()
};
res.verdicts
.insert((0, "Ping.status".into()), Verdict::Incorrect);
let out = xml(&res);
assert!(out.contains("errors=\"1\""), "{out}");
assert!(out.contains("failures=\"0\""), "{out}");
assert_eq!(out.matches("<failure").count(), 0, "one status only: {out}");
assert!(out.contains("<system-out>"), "{out}");
}
#[test]
fn a_renamed_time_field_is_still_the_cases_duration() {
let res = ReportResult {
column_order: vec!["Ping.took".into()],
rows: vec![row(&["a"], &[("Ping.took", "2500")])],
duration_columns: ["Ping.took".to_string()].into_iter().collect(),
..Default::default()
};
let out = xml(&res);
assert!(out.contains("time=\"2.500\""), "{out}");
}
#[test]
fn a_request_whose_time_is_reported_twice_did_not_take_twice_as_long() {
let res = ReportResult {
column_order: vec![
"Ping.Time".into(),
"Ping.took".into(),
"Ping.elapsed".into(),
],
rows: vec![row(
&["a"],
&[
("Ping.Time", "2500"),
("Ping.took", "2500"),
("Ping.elapsed", "2500"),
],
)],
duration_columns: ["Ping.took".to_string(), "Ping.elapsed".to_string()]
.into_iter()
.collect(),
..Default::default()
};
let out = xml(&res);
assert!(
out.contains("time=\"2.500\""),
"one request, one duration: {out}"
);
}
#[test]
fn two_requests_in_a_row_each_spend_their_own_time() {
let res = ReportResult {
column_order: vec!["Ping.Time".into(), "Pong.took".into()],
rows: vec![row(&["a"], &[("Ping.Time", "1500"), ("Pong.took", "500")])],
duration_columns: ["Pong.took".to_string()].into_iter().collect(),
..Default::default()
};
let out = xml(&res);
assert!(out.contains("time=\"2.000\""), "{out}");
}
#[test]
fn a_nonsense_timing_is_no_timing() {
let res = ReportResult {
column_order: vec!["A.Time".into(), "B.Time".into(), "C.Time".into()],
rows: vec![row(
&["a"],
&[("A.Time", "-5"), ("B.Time", "NaN"), ("C.Time", "—")],
)],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("time=\"0.000\""), "{out}");
assert!(
!out.contains("NaN") || !out.contains("time=\"NaN\""),
"{out}"
);
}
#[test]
fn comparison_targets_separate_the_cases_they_belong_to() {
let mut staging = row(&["a"], &[("Ping.status", "200")]);
staging.target = Some("staging <1>".into());
let mut prod = row(&["a"], &[("Ping.status", "500")]);
prod.target = Some("prod & co".into());
let res = ReportResult {
column_order: vec!["Ping.status".into()],
rows: vec![staging, prod],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("name=\"a [staging <1>]\""), "{out}");
assert!(out.contains("name=\"a [prod & co]\""), "{out}");
}
#[test]
fn a_long_multibyte_cell_is_cut_on_a_character_boundary() {
let body: String = "é".repeat(MAX_CELL + 10);
let res = ReportResult {
column_order: vec!["Body".into()],
rows: vec![row(&["a"], &[("Body", &body)])],
..Default::default()
};
let out = xml(&res);
assert!(out.contains('…'), "the cut is marked: {out:?}");
assert_eq!(out.matches('é').count(), MAX_CELL, "{}", out.len());
}
#[test]
fn a_cases_time_is_the_rows_own_milliseconds_in_seconds() {
let res = ReportResult {
column_order: vec!["Ping.Time".into(), "Pong.Time".into()],
rows: vec![row(&["a"], &[("Ping.Time", "1200"), ("Pong.Time", "300")])],
..Default::default()
};
let out = xml(&res);
assert!(out.contains("time=\"1.500\""), "{out}");
}
}