test/formatters/
pretty.rs

Help
1use std::io;
2use std::io::prelude::Write;
3
4use super::OutputFormatter;
5use crate::bench::fmt_bench_samples;
6use crate::console::{ConsoleTestDiscoveryState, ConsoleTestState, OutputLocation};
7use crate::test_result::TestResult;
8use crate::types::TestDesc;
9use crate::{term, time};
10
11pub(crate) struct PrettyFormatter<T> {
12    out: OutputLocation<T>,
13    use_color: bool,
14    time_options: Option<time::TestTimeOptions>,
15
16    /// Number of columns to fill when aligning names
17    max_name_len: usize,
18
19    is_multithreaded: bool,
20}
21
22impl<T: Write> PrettyFormatter<T> {
23    pub(crate) fn new(
24        out: OutputLocation<T>,
25        use_color: bool,
26        max_name_len: usize,
27        is_multithreaded: bool,
28        time_options: Option<time::TestTimeOptions>,
29    ) -> Self {
30        PrettyFormatter { out, use_color, max_name_len, is_multithreaded, time_options }
31    }
32
33    #[cfg(test)]
34    pub(crate) fn output_location(&self) -> &OutputLocation<T> {
35        &self.out
36    }
37
38    pub(crate) fn write_ok(&mut self) -> io::Result<()> {
39        self.write_short_result("ok", term::color::GREEN)
40    }
41
42    pub(crate) fn write_failed(&mut self) -> io::Result<()> {
43        self.write_short_result("FAILED", term::color::RED)
44    }
45
46    pub(crate) fn write_ignored(&mut self, message: Option<&'static str>) -> io::Result<()> {
47        if let Some(message) = message {
48            self.write_short_result(&format!("ignored, {message}"), term::color::YELLOW)
49        } else {
50            self.write_short_result("ignored", term::color::YELLOW)
51        }
52    }
53
54    pub(crate) fn write_time_failed(&mut self) -> io::Result<()> {
55        self.write_short_result("FAILED (time limit exceeded)", term::color::RED)
56    }
57
58    pub(crate) fn write_bench(&mut self) -> io::Result<()> {
59        self.write_pretty("bench", term::color::CYAN)
60    }
61
62    pub(crate) fn write_short_result(
63        &mut self,
64        result: &str,
65        color: term::color::Color,
66    ) -> io::Result<()> {
67        self.write_pretty(result, color)
68    }
69
70    pub(crate) fn write_pretty(&mut self, word: &str, color: term::color::Color) -> io::Result<()> {
71        match self.out {
72            OutputLocation::Pretty(ref mut term) => {
73                if self.use_color {
74                    term.fg(color)?;
75                }
76                term.write_all(word.as_bytes())?;
77                if self.use_color {
78                    term.reset()?;
79                }
80                term.flush()
81            }
82            OutputLocation::Raw(ref mut stdout) => {
83                stdout.write_all(word.as_bytes())?;
84                stdout.flush()
85            }
86        }
87    }
88
89    pub(crate) fn write_plain<S: AsRef<str>>(&mut self, s: S) -> io::Result<()> {
90        let s = s.as_ref();
91        self.out.write_all(s.as_bytes())?;
92        self.out.flush()
93    }
94
95    fn write_time(
96        &mut self,
97        desc: &TestDesc,
98        exec_time: Option<&time::TestExecTime>,
99    ) -> io::Result<()> {
100        if let (Some(opts), Some(time)) = (self.time_options, exec_time) {
101            let time_str = format!(" <{time}>");
102
103            let color = if self.use_color {
104                if opts.is_critical(desc, time) {
105                    Some(term::color::RED)
106                } else if opts.is_warn(desc, time) {
107                    Some(term::color::YELLOW)
108                } else {
109                    None
110                }
111            } else {
112                None
113            };
114
115            match color {
116                Some(color) => self.write_pretty(&time_str, color)?,
117                None => self.write_plain(&time_str)?,
118            }
119        }
120
121        Ok(())
122    }
123
124    fn write_results(
125        &mut self,
126        inputs: &Vec<(TestDesc, Vec<u8>)>,
127        results_type: &str,
128    ) -> io::Result<()> {
129        let results_out_str = format!("\n{results_type}:\n");
130
131        self.write_plain(&results_out_str)?;
132
133        let mut results = Vec::new();
134        let mut stdouts = String::new();
135        for (f, stdout) in inputs {
136            results.push(f.name.to_string());
137            if !stdout.is_empty() {
138                stdouts.push_str(&format!("---- {} stdout ----\n", f.name));
139                let output = String::from_utf8_lossy(stdout);
140                stdouts.push_str(&output);
141                stdouts.push('\n');
142            }
143        }
144        if !stdouts.is_empty() {
145            self.write_plain("\n")?;
146            self.write_plain(&stdouts)?;
147        }
148
149        self.write_plain(&results_out_str)?;
150        results.sort();
151        for name in &results {
152            self.write_plain(&format!("    {name}\n"))?;
153        }
154        Ok(())
155    }
156
157    pub(crate) fn write_successes(&mut self, state: &ConsoleTestState) -> io::Result<()> {
158        self.write_results(&state.not_failures, "successes")
159    }
160
161    pub(crate) fn write_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
162        self.write_results(&state.failures, "failures")
163    }
164
165    pub(crate) fn write_time_failures(&mut self, state: &ConsoleTestState) -> io::Result<()> {
166        self.write_results(&state.time_failures, "failures (time limit exceeded)")
167    }
168
169    fn write_test_name(&mut self, desc: &TestDesc) -> io::Result<()> {
170        let name = desc.padded_name(self.max_name_len, desc.name.padding());
171        if let Some(test_mode) = desc.test_mode() {
172            self.write_plain(format!("test {name} - {test_mode} ... "))?;
173        } else {
174            self.write_plain(format!("test {name} ... "))?;
175        }
176
177        Ok(())
178    }
179}
180
181impl<T: Write> OutputFormatter for PrettyFormatter<T> {
182    fn write_discovery_start(&mut self) -> io::Result<()> {
183        Ok(())
184    }
185
186    fn write_test_discovered(&mut self, desc: &TestDesc, test_type: &str) -> io::Result<()> {
187        self.write_plain(format!("{}: {test_type}\n", desc.name))
188    }
189
190    fn write_discovery_finish(&mut self, state: &ConsoleTestDiscoveryState) -> io::Result<()> {
191        fn plural(count: usize, s: &str) -> String {
192            match count {
193                1 => format!("1 {s}"),
194                n => format!("{n} {s}s"),
195            }
196        }
197
198        if state.tests != 0 || state.benchmarks != 0 {
199            self.write_plain("\n")?;
200        }
201
202        self.write_plain(format!(
203            "{}, {}\n",
204            plural(state.tests, "test"),
205            plural(state.benchmarks, "benchmark")
206        ))
207    }
208
209    fn write_run_start(&mut self, test_count: usize, shuffle_seed: Option<u64>) -> io::Result<()> {
210        let noun = if test_count != 1 { "tests" } else { "test" };
211        let shuffle_seed_msg = if let Some(shuffle_seed) = shuffle_seed {
212            format!(" (shuffle seed: {shuffle_seed})")
213        } else {
214            String::new()
215        };
216        self.write_plain(format!("\nrunning {test_count} {noun}{shuffle_seed_msg}\n"))
217    }
218
219    fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
220        // When running tests concurrently, we should not print
221        // the test's name as the result will be mis-aligned.
222        // When running the tests serially, we print the name here so
223        // that the user can see which test hangs.
224        if !self.is_multithreaded {
225            self.write_test_name(desc)?;
226        }
227
228        Ok(())
229    }
230
231    fn write_result(
232        &mut self,
233        desc: &TestDesc,
234        result: &TestResult,
235        exec_time: Option<&time::TestExecTime>,
236        _: &[u8],
237        _: &ConsoleTestState,
238    ) -> io::Result<()> {
239        if self.is_multithreaded {
240            self.write_test_name(desc)?;
241        }
242
243        match *result {
244            TestResult::TrOk => self.write_ok()?,
245            TestResult::TrFailed | TestResult::TrFailedMsg(_) => self.write_failed()?,
246            TestResult::TrIgnored => self.write_ignored(desc.ignore_message)?,
247            TestResult::TrBench(ref bs) => {
248                self.write_bench()?;
249                self.write_plain(format!(": {}", fmt_bench_samples(bs)))?;
250            }
251            TestResult::TrTimedFail => self.write_time_failed()?,
252        }
253
254        self.write_time(desc, exec_time)?;
255        self.write_plain("\n")
256    }
257
258    fn write_timeout(&mut self, desc: &TestDesc) -> io::Result<()> {
259        self.write_plain(format!(
260            "test {} has been running for over {} seconds\n",
261            desc.name,
262            time::TEST_WARN_TIMEOUT_S
263        ))
264    }
265
266    fn write_run_finish(&mut self, state: &ConsoleTestState) -> io::Result<bool> {
267        if state.options.display_output {
268            self.write_successes(state)?;
269        }
270        let success = state.failed == 0;
271        if !success {
272            if !state.failures.is_empty() {
273                self.write_failures(state)?;
274            }
275
276            if !state.time_failures.is_empty() {
277                self.write_time_failures(state)?;
278            }
279        }
280
281        self.write_plain("\ntest result: ")?;
282
283        if success {
284            // There's no parallelism at this point so it's safe to use color
285            self.write_pretty("ok", term::color::GREEN)?;
286        } else {
287            self.write_pretty("FAILED", term::color::RED)?;
288        }
289
290        let s = format!(
291            ". {} passed; {} failed; {} ignored; {} measured; {} filtered out",
292            state.passed, state.failed, state.ignored, state.measured, state.filtered_out
293        );
294
295        self.write_plain(s)?;
296
297        if let Some(ref exec_time) = state.exec_time {
298            let time_str = format!("; finished in {exec_time}");
299            self.write_plain(time_str)?;
300        }
301
302        self.write_plain("\n\n")?;
303
304        Ok(success)
305    }
306}
test/formatters/pretty.rs

test/formatters/
pretty.rs
