use std::io;
use std::io::prelude::Write;
use super::OutputFormatter;
use crate::bench::fmt_bench_samples;
use crate::console::{ConsoleTestDiscoveryState, ConsoleTestState, OutputLocation};
use crate::test_result::TestResult;
use crate::types::TestDesc;
use crate::{term, time};
pub(crate) struct PrettyFormatter<T> {
out: OutputLocation<T>,
use_color: bool,
time_options: Option<time::TestTimeOptions>,
max_name_len: usize,
is_multithreaded: bool,
}
impl<T: Write> PrettyFormatter<T> {
pub fn new(
out: OutputLocation<T>,
use_color: bool,
max_name_len: usize,
is_multithreaded: bool,
time_options: Option<time::TestTimeOptions>,
) -> Self {
PrettyFormatter { out, use_color, max_name_len, is_multithreaded, time_options }
}
#[cfg(test)]
pub fn output_location(&self) -> &OutputLocation<T> {
&self.out
}
pub fn write_ok(&mut self) -> io::Result<()> {
self.write_short_result("ok", term::color::GREEN)
}
pub fn write_failed(&mut self) -> io::Result<()> {
self.write_short_result("FAILED", term::color::RED)
}
pub fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {
if let Some(message) = message {
self.write_short_result(&format!("ignored, {message}"), term::color::YELLOW)
} else {
self.write_short_result("ignored", term::color::YELLOW)
}
}
pub fn write_time_failed(&mut self) -> io::Result<()> {
self.write_short_result("FAILED (time limit exceeded)", term::color::RED)
}
pub fn write_bench(&mut self) -> io::Result<()> {
self.write_pretty("bench", term::color::CYAN)
}
pub fn write_short_result(
&mut self,
result: &str,
color: term::color::Color,
) -> io::Result<()> {
self.write_pretty(result, color)
}
pub fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
match self.out {
OutputLocation::Pretty(ref mut term) => {
if self.use_color {
term.fg(color)?;
}
term.write_all(word.as_bytes())?;
if self.use_color {
term.reset()?;
}
term.flush()
}
OutputLocation::Raw(ref mut stdout) => {
stdout.write_all(word.as_bytes())?;
stdout.flush()
}
}
}
pub fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
let s = s.as_ref();
self.out.write_all(s.as_bytes())?;
self.out.flush()
}
fn write_time(
&mut self,
desc: &TestDesc,
exec_time: Option<&time::TestExecTime>,
) -> io::Result<()> {
if let (Some(opts), Some(time)) = (self.time_options, exec_time) {
let time_str = format!(" <{time}>");
let color = if self.use_color {
if opts.is_critical(desc, time) {
Some(term::color::RED)
} else if opts.is_warn(desc, time) {
Some(term::color::YELLOW)
} else {
None
}
} else {
None
};
match color {
Some(color) => self.write_pretty(&time_str, color)?,
None => self.write_plain(&time_str)?,
}
}
Ok(())
}
fn write_results(
&mut self,
inputs: &Vec<(TestDesc, Vec<u8>)>,
results_type: &str,
) -> io::Result<()> {
let results_out_str = format!("\n{results_type}:\n");
self.write_plain(&results_out_str)?;
let mut results = Vec::new();
let mut stdouts = String::new();
for (f, stdout) in inputs {
results.push(f.name.to_string());
if !stdout.is_empty() {
stdouts.push_str(&format!("---- {} stdout ----\n", f.name));
let output = String::from_utf8_lossy(stdout);
stdouts.push_str(&output);
stdouts.push('\n');
}
}
if !stdouts.is_empty() {
self.write_plain("\n")?;
self.write_plain(&stdouts)?;
}
self.write_plain(&results_out_str)?;
results.sort();
for name in &results {
self.write_plain(&format!(" {name}\n"))?;
}
Ok(())
}
pub fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_results(&state.not_failures, "successes")
}
pub fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_results(&state.failures, "failures")
}
pub fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
self.write_results(&state.time_failures, "failures (time limit exceeded)")
}
fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
let name = desc.padded_name(self.max_name_len, desc.name.padding());
if let Some(test_mode) = desc.test_mode() {
self.write_plain(format!("test {name} - {test_mode} ... "))?;
} else {
self.write_plain(format!("test {name} ... "))?;
}
Ok(())
}
}
impl<T: Write> OutputFormatter for PrettyFormatter<T> {
fn write_discovery_start(&mut self) -> io::Result<()> {
Ok(())
}
fn write_test_discovered(&mut self, desc: &TestDesc, test_type: &str) -> io::Result<()> {
self.write_plain(format!("{}: {test_type}\n", desc.name))
}
fn write_discovery_finish(&mut self, state: &ConsoleTestDiscoveryState) -> io::Result<()> {
fn plural(count: usize, s: &str) -> String {
match count {
1 => format!("1 {s}"),
n => format!("{n} {s}s"),
}
}
if state.tests != 0 || state.benchmarks != 0 {
self.write_plain("\n")?;
}
self.write_plain(format!(
"{}, {}\n",
plural(state.tests, "test"),
plural(state.benchmarks, "benchmark")
))
}
fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()> {
let noun = if test_count != 1 { "tests" } else { "test" };
let shuffle_seed_msg = if let Some(shuffle_seed) = shuffle_seed {
format!(" (shuffle seed: {shuffle_seed})")
} else {
String::new()
};
self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
}
fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
if !self.is_multithreaded {
self.write_test_name(desc)?;
}
Ok(())
}
fn write_result(
&mut self,
desc: &TestDesc,
result: &TestResult,
exec_time: Option<&time::TestExecTime>,
_: &[u8],
_: &ConsoleTestState,
) -> io::Result<()> {
if self.is_multithreaded {
self.write_test_name(desc)?;
}
match *result {
TestResult::TrOk => self.write_ok()?,
TestResult::TrFailed | TestResult::TrFailedMsg(_) => self.write_failed()?,
TestResult::TrIgnored => self.write_ignored(desc.ignore_message)?,
TestResult::TrBench(ref bs) => {
self.write_bench()?;
self.write_plain(format!(": {}", fmt_bench_samples(bs)))?;
}
TestResult::TrTimedFail => self.write_time_failed()?,
}
self.write_time(desc, exec_time)?;
self.write_plain("\n")
}
fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
self.write_plain(format!(
"test {} has been running for over {} seconds\n",
desc.name,
time::TEST_WARN_TIMEOUT_S
))
}
fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
if state.options.display_output {
self.write_successes(state)?;
}
let success = state.failed == 0;
if !success {
if !state.failures.is_empty() {
self.write_failures(state)?;
}
if !state.time_failures.is_empty() {
self.write_time_failures(state)?;
}
}
self.write_plain("\ntest result: ")?;
if success {
self.write_pretty("ok", term::color::GREEN)?;
} else {
self.write_pretty("FAILED", term::color::RED)?;
}
let s = format!(
". {} passed; {} failed; {} ignored; {} measured; {} filtered out",
state.passed, state.failed, state.ignored, state.measured, state.filtered_out
);
self.write_plain(s)?;
if let Some(ref exec_time) = state.exec_time {
let time_str = format!("; finished in {exec_time}");
self.write_plain(time_str)?;
}
self.write_plain("\n\n")?;
Ok(success)
}
}