Difficult to read test failure messages when assertions fail

[DavidAntliff]

This is for assertables-9.8.0, with Rust 1.88.0.

I'm using assertables to create a custom test assertion. The intention is to compare lines of an assembly file with the "expected" output, but to ignore whitespace, thus the lines are compared "word by word". If it fails, I would like the test error message to clearly show the mismatched line.

Maybe I'm just using it incorrectly, but my error messages aren't very readable:

 a debug: `Err("assertion failed: `assert_eq!(a, b)`\nhttps://docs.rs/assertables/0.1.0/assertables/macro.assert_eq.html\n a label: `line_parts`,\n a debug: `[\"ret\"]`,\n b label: `expected_parts`,\n b debug: `[\"retfoo\"]`")`

Aside: I'm not sure why that bogus URL appears in the output - it's a 404.

Here's the code that caused that error (retfoo should be ret to pass):

        assert_ok!(listing_is_equivalent(
            &listing.unwrap(),
            &format!(
                r#"
                .text
            {simple}:
                retfoo
            "#
            )
        ));

    fn listing_is_equivalent(listing: &str, expected: &str) -> Result<(), String> {
        let listing = listing
            .lines()
            .filter(|line| !line.trim().is_empty())
            .map(str::trim)
            .collect::<Vec<_>>();
        let expected = expected
            .lines()
            .filter(|line| !line.trim().is_empty())
            .map(str::trim)
            .collect::<Vec<_>>();

        assert_eq_as_result!(listing.len(), expected.len())?;

        for (actual, expected) in listing.iter().zip(expected) {
            asm_line_equivalent(actual, expected)?;
        }
        Ok(())
    }

    fn asm_line_equivalent(line: &str, expected: &str) -> Result<(), String> {
        let line = line.trim();
        let expected = expected.trim();

        let line_parts = line.split_whitespace().collect::<Vec<_>>();
        let expected_parts = expected.split_whitespace().collect::<Vec<_>>();

        assert_eq_as_result!(line_parts, expected_parts)
    }

Incidentally, is there a way to annotate the assertion failures? For example, it would be nice in listing_is_equivalent() to be able to attach some info to the error returned when asm_line_equivalent() fails, to show that the internal assert_eq failed for "line 3", which I could determine in the zip-loop.

[joelparkerhenderson]

Great question and explanation.

If I understand you correctly, I have a first suggestion that may get you more of what you want by using a different crate.

Consider something like this:

1. Refactor your code to create a function that parses your block of text data into a better shape, such as a list of lines, where each line contains a list of words.

2. Switch from the crate assertables to the crate pretty_assertions which shows colorful output lines the way you want.

---

Create a function to get your data into the correct shape:

/// Parse a block of text into lines of words.
fn lines_of_words(block: &str) -> Vec<Vec<&str>> {
    block.lines()
        .filter(|line| !line.trim().is_empty())
        .map(|line| line.split_whitespace().collect::<Vec<&str>>())
        .collect::<Vec<Vec<&str>>>()
}

Add this to your file Cargo.toml:

[dev-dependencies]
pretty_assertions = "*"

Now you can compare the blocks and get colorful formatted output that highlights the differences:

use pretty_assertions::assert_eq;

let actual = "a b c\nd x f\n";
let expect = "a b c\nd e f\n";
assert_eq!(
    lines_of_words(actual), 
    lines_of_words(expect),
);

Output looks like this and has red-green colors:

Diff < left / right > :
 [
     [
         "a",
         "b",
         "c",
     ],
     [
         "d",
<        "x",
>        "e",
         "f",
     ],
 ]

If you like, you can even create your own macro:

#[macro_export]
macro_rules! assert_assembly_language_eq {
    ($left:expr, $right:expr $(,)?) => {
        assert_eq!(
            lines_of_words($left), 
            lines_of_words($right),
        );
    };
}

You can call your own macro like this:

let actual = "a b c\nd x f\n";
let expect = "a b c\nd e f\n";
assert_assembly_language_eq!(actual, expect);

If that all the above is good for what you hoping to do, then that's great.

You also asked about how to do annotations for line numbers. One way that's especially easy is to add the line number to your data shape:

/// Parse a block of text into lines of words, with a line index.
pub fn lines_of_words(block: &str) -> Vec<(usize, Vec<&str>)> {
    block.lines()
        .filter(|line| !line.trim().is_empty())
        .enumerate()
        .map(|(index, line)| (index, line.split_whitespace().collect::<Vec<&str>>()))
        .collect::<Vec<(usize, Vec<&str>)>>()
}

Output looks like this, with line numbering, and has red-green colors:

Diff < left / right > :
 [
     (
         0,
         [
             "a",
             "b",
             "c",
         ],
     ),
     (
         1,
         [
             "d",
<            "x",
>            "e",
             "f",
         ],
     ),
 ]

If you're curious about why to use the crate assertables, it's for when a developer wants more capabilities: there are more kinds of comparisons, and more forms to do comparisons at runtime, and easy ways to copy the open source code so you can create your own custom assertions.

Thanks for the heads up about the bogus URL. I'll fix that bug now.