Pretty-print assertion failures in test with unstable flag.

Author: de-vri-es

library/test/src/cli.rs

@@ -23,6 +23,7 @@ pub struct TestOpts {
     pub format: OutputFormat,
     pub shuffle: bool,
     pub shuffle_seed: Option<u64>,
+    pub pretty_print_assertions: bool,
     pub test_threads: Option<usize>,
     pub skip: Vec<String>,
     pub time_options: Option<TestTimeOptions>,
@@ -147,6 +148,11 @@ fn optgroups() -> getopts::Options {
             "shuffle-seed",
             "Run tests in random order; seed the random number generator with SEED",
             "SEED",
+        )
+        .optflag(
+            "",
+            "pretty-print-assertions",
+            "Pretty-print assertion failures using experimental formatting.",
         );
     opts
 }
@@ -276,6 +282,8 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
     let test_threads = get_test_threads(&matches)?;
     let color = get_color_config(&matches)?;
     let format = get_format(&matches, quiet, allow_unstable)?;
+    let pretty_print_assertions =
+        unstable_optflag!(matches, allow_unstable, "pretty-print-assertions");
 
     let options = Options::new().display_output(matches.opt_present("show-output"));
 
@@ -294,6 +302,7 @@ fn parse_opts_impl(matches: getopts::Matches) -> OptRes {
         format,
         shuffle,
         shuffle_seed,
+        pretty_print_assertions,
         test_threads,
         skip,
         time_options,

library/test/src/console.rs

@@ -13,6 +13,7 @@ use super::{
     formatters::{JsonFormatter, JunitFormatter, OutputFormatter, PrettyFormatter, TerseFormatter},
     helpers::{concurrency::get_concurrency, metrics::MetricMap},
     options::{Options, OutputFormat},
+    pretty_print_assertion::pretty_print_assertion,
     run_tests, term,
     test_result::TestResult,
     time::{TestExecTime, TestSuiteExecTime},
@@ -25,6 +26,16 @@ pub enum OutputLocation<T> {
     Raw(T),
 }
 
+impl<T> OutputLocation<T> {
+    /// Check if the output location supports ANSI color codes.
+    pub fn supports_ansi_colors(&self) -> bool {
+        match self {
+            OutputLocation::Pretty(term) => term.supports_ansi_colors(),
+            OutputLocation::Raw(_) => false,
+        }
+    }
+}
+
 impl<T: Write> Write for OutputLocation<T> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match *self {
@@ -251,12 +262,27 @@ fn on_test_event(
 
 /// A simple console test runner.
 /// Runs provided tests reporting process and results to the stdout.
+///
+/// If pretty-printing of assertion failures is enabled, this installs a panic hook.
 pub fn run_tests_console(opts: &TestOpts, tests: Vec<TestDescAndFn>) -> io::Result<bool> {
     let output = match term::stdout() {
         None => OutputLocation::Raw(io::stdout()),
         Some(t) => OutputLocation::Pretty(t),
     };
 
+    if opts.pretty_print_assertions {
+        let panic_hook = std::panic::take_hook();
+        let use_color = opts.use_color() && output.supports_ansi_colors();
+        std::panic::set_hook(Box::new(move |info| {
+            if let Some(assert) = info.assert_info() {
+                let loc = *info.location().unwrap();
+                let _ = pretty_print_assertion(assert, loc, use_color);
+            } else {
+                panic_hook(info)
+            }
+        }));
+    }
+
     let max_name_len = tests
         .iter()
         .max_by_key(|t| len_if_padded(*t))

library/test/src/lib.rs

@@ -23,10 +23,12 @@
 #![feature(libc)]
 #![feature(rustc_private)]
 #![feature(nll)]
+#![feature(core_panic)]
 #![feature(available_parallelism)]
 #![feature(bench_black_box)]
 #![feature(internal_output_capture)]
 #![feature(panic_unwind)]
+#![feature(panic_internals)]
 #![feature(staged_api)]
 #![feature(termination_trait_lib)]
 #![feature(test)]
@@ -79,6 +81,7 @@ mod event;
 mod formatters;
 mod helpers;
 mod options;
+mod pretty_print_assertion;
 pub mod stats;
 mod term;
 mod test_result;

library/test/src/pretty_print_assertion.rs

@@ -0,0 +1,110 @@
+use core::panic::assert_info::{AssertInfo, Assertion, BinaryAssertion, BoolAssertion};
+use core::panic::Location;
+
+const RED: &str = "\x1b[31m";
+const YELLOW: &str = "\x1b[33m";
+const BLUE: &str = "\x1b[34m";
+const CYAN: &str = "\x1b[36m";
+const BOLD: &str = "\x1b[1m";
+const RESET: &str = "\x1b[0m";
+
+/// Print an assertion to standard error.
+///
+/// If `ansi_colors` is true, this function unconditionally prints ANSI color codes.
+/// It should only be set to true only if it is known that the terminal supports it.
+pub fn pretty_print_assertion(assert: &AssertInfo<'_>, loc: Location<'_>, ansi_colors: bool) {
+    if ansi_colors {
+        print_pretty_header(loc);
+        match &assert.assertion {
+            Assertion::Bool(assert) => print_pretty_bool_assertion(assert),
+            Assertion::Binary(assert) => print_pretty_binary_assertion(assert),
+        }
+        if let Some(msg) = &assert.message {
+            print_pretty_message(msg);
+        }
+    } else {
+        print_plain_header(loc);
+        match &assert.assertion {
+            Assertion::Bool(assert) => print_plain_bool_assertion(assert),
+            Assertion::Binary(assert) => print_plain_binary_assertion(assert),
+        }
+        if let Some(msg) = &assert.message {
+            print_plain_message(msg);
+        }
+    }
+}
+
+fn print_plain_header(loc: Location<'_>) {
+    eprintln!("Assertion failed at {}:{}:{}:", loc.file(), loc.line(), loc.column())
+}
+
+fn print_pretty_header(loc: Location<'_>) {
+    eprintln!(
+        "{bold}{red}Assertion failed{reset} at {bold}{file}{reset}:{line}:{col}:",
+        red = RED,
+        bold = BOLD,
+        reset = RESET,
+        file = loc.file(),
+        line = loc.line(),
+        col = loc.column(),
+    );
+}
+
+fn print_plain_bool_assertion(assert: &BoolAssertion) {
+    eprintln!("Assertion:\n  {}", assert.expr);
+    eprintln!("Expansion:\n  false");
+}
+
+fn print_pretty_bool_assertion(assert: &BoolAssertion) {
+    eprintln!(
+        "{bold}Assertion:{reset}\n  {cyan}{expr}{reset}",
+        cyan = CYAN,
+        reset = RESET,
+        bold = BOLD,
+        expr = assert.expr,
+    );
+    eprintln!(
+        "{bold}Expansion:{reset}\n  {cyan}false{reset}",
+        cyan = CYAN,
+        bold = BOLD,
+        reset = RESET,
+    );
+}
+
+fn print_plain_binary_assertion(assert: &BinaryAssertion<'_>) {
+    eprintln!("Assertion:\n  {} {} {}", assert.left_expr, assert.op, assert.right_expr);
+    eprintln!("Expansion:\n  {:?} {} {:?}", assert.left_val, assert.op, assert.right_val);
+}
+
+fn print_pretty_binary_assertion(assert: &BinaryAssertion<'_>) {
+    eprintln!(
+        "{bold}Assertion:{reset}\n  {cyan}{left} {bold}{blue}{op}{reset} {yellow}{right}{reset}",
+        cyan = CYAN,
+        blue = BLUE,
+        yellow = YELLOW,
+        bold = BOLD,
+        reset = RESET,
+        left = assert.left_expr,
+        op = assert.op,
+        right = assert.right_expr,
+    );
+    eprintln!(
+        "{bold}Expansion:{reset}\n  {cyan}{left:?} {bold}{blue}{op}{reset} {yellow}{right:?}{reset}",
+        cyan = CYAN,
+        blue = BLUE,
+        yellow = YELLOW,
+        bold = BOLD,
+        reset = RESET,
+        left = assert.left_val,
+        op = assert.op,
+        right = assert.right_val,
+    );
+}
+
+fn print_plain_message(message: &std::fmt::Arguments<'_>) {
+    eprintln!("Message:\n  {}", message);
+}
+
+fn print_pretty_message(message: &std::fmt::Arguments<'_>) {
+    eprintln!("{bold}Message:{reset}\n  {msg}", bold = BOLD, reset = RESET, msg = message,);
+}

library/test/src/tests.rs

@@ -47,6 +47,7 @@ impl TestOpts {
             format: OutputFormat::Pretty,
             shuffle: false,
             shuffle_seed: None,
+            pretty_print_assertions: false,
             test_threads: None,
             skip: vec![],
             time_options: None,

src/tools/compiletest/src/main.rs

@@ -508,6 +508,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         color: config.color,
         shuffle: false,
         shuffle_seed: None,
+        pretty_print_assertions: false,
         test_threads: None,
         skip: vec![],
         list: false,