Include macro name in pretty printed assertion.

de-vri-es · jakoschiko · commit 3ff9a91d73a9 · 2021-10-20T21:22:18.000+02:00
And use a comma to separate arguments of `assert_eq` and `assert_ne`.
This has two advantages:
 * The printed text more closely matches the actual source code.
 * It avoids changing the meaning of $left == $right if $left or $right
   contain operators themselves.
diff --git a/library/core/src/panic/assert_info.rs b/library/core/src/panic/assert_info.rs
@@ -5,6 +5,8 @@ use crate::fmt::Debug;
 pub struct AssertInfo<'a> {
     /// The assertion that failed.
     pub assertion: Assertion<'a>,
+    /// The name of the macro that triggered the panic.
+    pub macro_name: &'static str,
     /// Optional additional message to include in the failure report.
     pub message: Option<crate::fmt::Arguments<'a>>,
 }
diff --git a/library/core/src/panicking.rs b/library/core/src/panicking.rs
@@ -187,10 +187,10 @@ fn assert_failed_inner(
     right_val: &dyn fmt::Debug,
     args: Option<fmt::Arguments<'_>>,
 ) -> ! {
-    let op = match kind {
-        AssertKind::Eq => "==",
-        AssertKind::Ne => "!=",
-        AssertKind::Match => "matches",
+    let (op, macro_name) = match kind {
+        AssertKind::Eq => ("==", "assert_eq"),
+        AssertKind::Ne => ("!=", "assert_ne"),
+        AssertKind::Match => ("matches", "assert_matches"),
     };
 
     match args {
@@ -209,6 +209,7 @@ fn assert_failed_inner(
                     left_val,
                     right_val,
                 }),
+                macro_name,
                 message: Some(args),
             })),
         ),
@@ -227,6 +228,7 @@ fn assert_failed_inner(
                     left_val,
                     right_val,
                 }),
+                macro_name,
                 message: None,
             })),
         ),
diff --git a/library/test/src/pretty_print_assertion.rs b/library/test/src/pretty_print_assertion.rs
@@ -4,6 +4,7 @@ use core::panic::Location;
 const RED: &str = "\x1b[31m";
 const YELLOW: &str = "\x1b[33m";
 const BLUE: &str = "\x1b[34m";
+const MAGENTA: &str = "\x1b[35m";
 const CYAN: &str = "\x1b[36m";
 const BOLD: &str = "\x1b[1m";
 const RESET: &str = "\x1b[0m";
@@ -13,20 +14,21 @@ const RESET: &str = "\x1b[0m";
 /// 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) {
+    let macro_name = assert.macro_name;
     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),
+            Assertion::Bool(assert) => print_pretty_bool_assertion(macro_name, assert),
+            Assertion::Binary(assert) => print_pretty_binary_assertion(macro_name, 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),
+            Assertion::Bool(assert) => print_plain_bool_assertion(macro_name, assert),
+            Assertion::Binary(assert) => print_plain_binary_assertion(macro_name, assert),
         }
         if let Some(msg) = &assert.message {
             print_plain_message(msg);
@@ -50,55 +52,111 @@ fn print_pretty_header(loc: Location<'_>) {
     );
 }
 
-fn print_plain_bool_assertion(assert: &BoolAssertion) {
-    eprintln!("Assertion:\n  {}", assert.expr);
-    eprintln!("Expansion:\n  false");
+fn print_plain_bool_assertion(macro_name: &'static str, assert: &BoolAssertion) {
+    eprint!(
+        concat!(
+            "Assertion:\n",
+            "  {macro_name}!( {expr} )\n",
+            "Expansion:\n",
+            "  {macro_name}!( false )\n",
+        ),
+        macro_name = macro_name,
+        expr = assert.expr,
+    )
 }
 
-fn print_pretty_bool_assertion(assert: &BoolAssertion) {
-    eprintln!(
-        "{bold}Assertion:{reset}\n  {cyan}{expr}{reset}",
+fn print_pretty_bool_assertion(macro_name: &'static str, assert: &BoolAssertion) {
+    eprint!(
+        concat!(
+            "{bold}Assertion:{reset}\n",
+            "  {magenta}{macro_name}!( {cyan}{expr} {magenta}){reset}\n",
+            "{bold}Expansion:{reset}\n",
+            "  {magenta}{macro_name}!( {cyan}false {magenta}){reset}\n",
+        ),
+        magenta = MAGENTA,
         cyan = CYAN,
         reset = RESET,
         bold = BOLD,
+        macro_name = macro_name,
         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_plain_binary_assertion(macro_name: &'static str, assert: &BinaryAssertion<'_>) {
+    if macro_name == "assert_eq" || macro_name == "assert_ne" {
+        eprint!(
+            concat!(
+                "Assertion:\n",
+                "  {macro_name}!( {left_expr}, {right_expr} )\n",
+                "Expansion:\n",
+                "  {macro_name}!( {left_val:?}, {right_val:?} )\n",
+            ),
+            macro_name = macro_name,
+            left_expr = assert.left_expr,
+            right_expr = assert.right_expr,
+            left_val = assert.left_val,
+            right_val = assert.right_val,
+        );
+    } else {
+        eprint!(
+            concat!(
+                "Assertion:\n",
+                "  {macro_name}!( {left_expr} {op} {right_expr} )\n",
+                "Expansion:\n",
+                "  {macro_name}!( {left_val:?} {op} {right_val:?} )\n",
+            ),
+            macro_name = macro_name,
+            op = assert.op,
+            left_expr = assert.left_expr,
+            right_expr = assert.right_expr,
+            left_val = assert.left_val,
+            right_val = 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_pretty_binary_assertion(macro_name: &'static str, assert: &BinaryAssertion<'_>) {
+    if macro_name == "assert_eq" || macro_name == "assert_ne" {
+        eprint!(
+            concat!(
+                "{bold}Assertion:{reset}\n",
+                "  {magenta}{macro_name}!( {cyan}{left_expr}{magenta}, {yellow}{right_expr} {magenta}){reset}\n",
+                "{bold}Expansion:{reset}\n",
+                "  {magenta}{macro_name}!( {cyan}{left_val:?}{magenta}, {yellow}{right_val:?} {magenta}){reset}\n",
+            ),
+            cyan = CYAN,
+            magenta = MAGENTA,
+            yellow = YELLOW,
+            bold = BOLD,
+            reset = RESET,
+            macro_name = macro_name,
+            left_expr = assert.left_expr,
+            right_expr = assert.right_expr,
+            left_val = assert.left_val,
+            right_val = assert.right_val,
+        );
+    } else {
+        eprint!(
+            concat!(
+                "{bold}Assertion:{reset}\n",
+                "  {magenta}{macro_name}!( {cyan}{left_expr} {bold}{blue}{op}{reset} {yellow}{right_expr} {magenta}){reset}\n",
+                "{bold}Expansion:{reset}\n",
+                "  {magenta}{macro_name}!( {cyan}{left_val:?} {bold}{blue}{op}{reset} {yellow}{right_val:?} {magenta}){reset}\n",
+            ),
+            blue = BLUE,
+            cyan = CYAN,
+            magenta = MAGENTA,
+            yellow = YELLOW,
+            bold = BOLD,
+            reset = RESET,
+            macro_name = macro_name,
+            op = assert.op,
+            left_expr = assert.left_expr,
+            right_expr = assert.right_expr,
+            left_val = assert.left_val,
+            right_val = assert.right_val,
+        );
+    };
 }
 
 fn print_plain_message(message: &std::fmt::Arguments<'_>) {

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,8 @@ use crate::fmt::Debug;`
`5`	`5`	`pub struct AssertInfo<'a> {`
`6`	`6`	`/// The assertion that failed.`
`7`	`7`	`pub assertion: Assertion<'a>,`
	`8`	`+ /// The name of the macro that triggered the panic.`
	`9`	`+ pub macro_name: &'static str,`
`8`	`10`	`/// Optional additional message to include in the failure report.`
`9`	`11`	`pub message: Option<crate::fmt::Arguments<'a>>,`
`10`	`12`	`}`