[rustc.git] / vendor / tester / src / formatters / pretty.rs

use std::{io, io::prelude::Write};

use super::OutputFormatter;
use crate::{
    bench::fmt_bench_samples,
    console::{ConsoleTestState, OutputLocation},
    test_result::TestResult,
    time,
    types::TestDesc,
};

pub(crate) struct PrettyFormatter<T> {
    out: OutputLocation<T>,
    use_color: bool,
    time_options: Option<time::TestTimeOptions>,

    /// Number of columns to fill when aligning names
    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) -> io::Result<()> {
        self.write_short_result("ignored", term::color::YELLOW)
    }

    pub fn write_allowed_fail(&mut self) -> io::Result<()> {
        self.write_short_result("FAILED (allowed)", 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 opts.colored {
                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{}:\n", results_type);

        self.write_plain(&results_out_str)?;

        let mut results = Vec::new();
        let mut stdouts = String::new();
        for &(ref f, ref 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!("    {}\n", name))?;
        }
        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());
        self.write_plain(&format!("test {} ... ", name))?;

        Ok(())
    }
}

impl<T: Write> OutputFormatter for PrettyFormatter<T> {
    fn write_run_start(&mut self, test_count: usize) -> io::Result<()> {
        let noun = if test_count != 1 { "tests" } else { "test" };
        self.write_plain(&format!("\nrunning {} {}\n", test_count, noun))
    }

    fn write_test_start(&mut self, desc: &TestDesc) -> io::Result<()> {
        // When running tests concurrently, we should not print
        // the test's name as the result will be mis-aligned.
        // When running the tests serially, we print the name here so
        // that the user can see which test hangs.
        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()?,
            TestResult::TrAllowedFail => self.write_allowed_fail()?,
            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<()> {
        if self.is_multithreaded {
            self.write_test_name(desc)?;
        }

        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 {
            // There's no parallelism at this point so it's safe to use color
            self.write_pretty("ok", term::color::GREEN)?;
        } else {
            self.write_pretty("FAILED", term::color::RED)?;
        }

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