use super::Runner;
use super::generated::CRATE;
use super::outcomes::Outcomes;
use super::programs::{Built, Line, Rendered};
use crate::protocol::{Cases, Kind, Status, Verdict};
use serde_json::json;
use std::collections::HashMap;
impl Runner {
pub(super) fn setup_module(&self) -> Option<String> {
let path = self.analysis.abs(self.analysis.setup.as_ref()?);
path.is_file().then(|| format!("#[path = {:?}] mod setup;", path.to_string_lossy()))
}
fn cases_program(&self) -> Built {
let built = self.cases.get_or_init(|| {
let columns = if self.analysis.setup_names().iter().any(|name| name == "COLUMNS") { "setup::COLUMNS" } else { "&[]" };
let source = format!(
"#![allow(unused)]\n{}\nfn main() {{\n {CRATE}::harness::serve::cases(setup::CASES, {columns});\n}}\n",
self.setup_module().unwrap_or_default()
);
self.build_program(0, &|_| Rendered { source: source.clone(), lines: HashMap::new() })
});
built.clone()
}
pub(super) fn run_cases(&self, table: &Cases) -> Vec<Verdict> {
let at = format!("cases \"{}\" at L{}", table.runner, table.line);
let refuse = |message: String| {
vec![Outcomes::of(Status::Error, message).verdict(&table.page, table.line, Kind::Cases)]
};
let Some(setup) = &self.analysis.setup else {
return refuse(format!(
"{at}: no setup module is configured (\"setup\" in docattest.config.json)"
));
};
if self.setup_module().is_none() {
return refuse(format!("{at}: setup module {setup} not found"));
}
if table.rows.is_empty() {
return Vec::new();
}
let program = self.cases_program();
let Some(binary) = program.binary else {
return refuse(format!(
"{at}: setup module {setup} failed to load: {}",
program.failure.unwrap_or_default()
));
};
let rows: Vec<_> = table.rows.iter().map(|row| json!({ "values": row.values })).collect();
let told = json!({ "runner": table.runner, "setup": setup, "line": table.line, "header": table.header, "rows": rows });
match self.serve(&binary, Some(told), table.rows.len()) {
Err(failed) => refuse(failed),
Ok(answers) => table
.rows
.iter()
.zip(&answers)
.map(|(row, answer)| {
let name = format!("{}:{} {}", table.page, row.line, row.name);
self.row_outcome(&name, answer).verdict(&table.page, row.line, Kind::Cases)
})
.collect(),
}
}
fn row_outcome(&self, name: &str, answer: &Line) -> Outcomes {
if answer.timeout {
return Outcomes::fail(format!("{name}: {}", self.timed_out()));
}
if let Some(panic) = &answer.panic {
return Outcomes::fail(format!("{name}: panicked: {panic}"));
}
if let Some(lost) = &answer.lost {
return Outcomes::fail(format!("{name}: {lost}"));
}
match answer.value.as_str().filter(|why| !why.is_empty()) {
Some(why) => Outcomes::fail(format!("{name}: {why}")),
None => Outcomes::pass(name),
}
}
}