This is a parity issue with assert_eq!

// This works:
assert_eq!(vec![1, 2, 3], [1, 2, 3]);

// This does not:
assert_equal!(vec![1, 2, 3], [1, 2, 3]);

error[E0308]: mismatched types
   --> src/sampler.rs:429:38
    |
429 |         assert_equal!(vec![1, 2, 3], [1, 2, 3]);
    |                                      ^^^^^^^^^
    |                                      |
    |                                      expected struct `std::vec::Vec`, found array `[{integer}; 3]`
    |                                      help: try using a conversion method: `[1, 2, 3].to_vec()`
    |
    = note: expected struct `std::vec::Vec<{integer}>`
                found array `[{integer}; 3]`

It seems that assert_matches_snapshot!(T) needs T to implement Display. This is a pretty restrictive requirement IMO, and Debug should suffice.

The current workaround id to format! T :assert_matches_snapshot!(format!("{:?}")), but this should not be necessary.

What do you think?

warning: panic message is not a string literal
   --> term/src/test/mod.rs:366:5
    |
366 | /     k9::snapshot!(
367 | |         term.get_semantic_zones().unwrap(),
368 | |         "
369 | | [
...   |
378 | | "
379 | |     );
    | |______^
    |
    = note: `#[warn(non_fmt_panic)]` on by default
    = note: this is no longer accepted in Rust 2021
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

and similarly for the assert_equals macro, which I've aliased here:

warning: panic message is not a string literal
   --> wezterm-font/src/shaper/harfbuzz.rs:512:13
    |
512 | /             assert_eq!(
513 | |                 info,
514 | |                 vec![GlyphInfo {
515 | |                     cluster: 0,
...   |
526 | |                 },]
527 | |             );
    | |______________^
    |
    = note: this is no longer accepted in Rust 2021
    = note: this warning originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

// success if the closure inside panics, panics if the closure doesn't panic
assert_panics!(|| {
  panic!("sup y'all");
});

see https://doc.rust-lang.org/std/panic/fn.catch_unwind.html

These are my notes and thoughts after trying out k9.

• wish it showed PASS like Jest
• show docs on hover in IDE (like other crates)
• better error message for snapshot failure (when no snapshot present)
• couldn't get snapshot assertion to work with example from docs (i blame myself)
• also, could explain the _r assertions better and when you might want to use one

README

• could be nice to have a quick walkthrough like jest
• add installation instructions

The MIT license requires that published / redistributed sources include a copy of the license text. This isn't the case for source code of the k9 crate that is published / redistributed via https://crates.io.

This PR adds a symlink in the k9 directory that points at the LICENSE file in the repository root, which makes cargo include the file when packaging / publishing the crate.

Note that if you are publishing this crate from an operating system which doesn't support symbolic links (Windows, I'm looking at you), a full copy of the file might be needed in the k9 directory, instead, to have cargo pick it up correctly.

I spotted a mistake in the README, so cloned the repo to open a PR, and VSCode found a few more in the rest of the repo, so have also fixed those whilst I'm here :-)

This pull requests fixes two problems with Result-related assertions I've come across:

1. It decouples the type arguments in assert_err and assert_ok, so that constructs like

   let result: Result<usize, &str> = Ok(1);
   assert_err!(result);
   

   should work now

2. It fixes the argument names in the three-argument variant of assert_err_matches_regex, so that this variant can be used again.

Was about to fix the use of k9::assert_matches_inline_snapshot! and after writing the test realized it does work as intented so no fixing necessary, just adding the test to make sure it keeps working.

This PR improves support for colors in output when running tests built with buck. By default the colored module would not produce output since it disables colors when stdout is a tty: https://github.com/mackwic/colored/blob/master/src/control.rs#L105-L114

We detect if buck is being used and if so, force colored output.

The standard assertion macros generally pass the error message and arguments to the panic! macro. k9 just seems to allow for a lone string without formatting, which means that migrating this example from the bottom of the docs:

https://doc.rust-lang.org/std/macro.assert_eq.html

assert_eq!(a, b, "we are testing addition with {} and {}", a, b);

to k9 needs to done like this:

assert_equal!(a, b, format!("we are testing addition with {} and {}", a, b));

Hi Aaron,

This PR addresses #83 although it's very much a work in progress and I am working to fix all the bugs and issues caused by introducing the new change.

Thank you for letting me work on this.

Yours Sincerely, Hannan

Usecase: Difference between two structs. Assertion: assert_equal

Current Output:

Collapsed Output:

Method: String Iteration

Implementation:

1. Computed the index of each occurrence with reference to (- or +). // [4, 5, 16, 17, 20, 21]
2. I have a cur_index and a peek_index.
3. If the difference between cur_index and peek_index is <= 5, I'll have those index and the intermediate values in the final collapsed output else I have a .... // [4, 5, 16, 17, 18, 19, 20, 21]

we have line! and column! macros. we can technically take out a pice of code with some context around it where assertion failed and add it to the error message e.g.

Assertion Failure!

43 | fn do something() {
44 |   let stuff = 1
45 |   assert_equal!(stuff, 2);
46 |  }

    assert_err_matches_regex!(
        conn.query_raw("SELECT 1").await,
        "time out"
    );

works, but

    assert_err_matches_regex!(
        conn.query_raw("SELECT 1").await,
        "time out",
    );

doesn't