Add possibility to replace assert_eq! with custom assertion

[frondeus]

When using => expected syntax it could be nice to set up what assertion shall we use.
It might be extra attribute:

#[test_case("foo" => "bar")]
#[test_case_assert_macro(assert_diff)]
fn test(input: &str) -> String { input.to_string() }

this could be expanded into:

mod test {
    use super::*;
    fn test(input: &str) -> String { input.to_string() }
    
    #[test]
    fn foo_expects_bar() {
       let actual = test("foo");
       assert_diff!("bar", actual);
    }

[frondeus]

The question is - should this setting be active for one test_case or for all test_cases

[Ryneqq]

How about

#[test_case("foo" => "bar")]
#[test_case_assert_macro(assert_diff)]

to

#[test_case[assert_diff]("foo" => "bar)]

[StragaSevera]

Is there any progress on this issue? I would be very glad to be able to set the assertion macro globally or locally and have the clean => syntax.

[luke-biel]

Unfortunately not. Life called and neither me nor @frondeus have a lot of free time, so test-case lives in suspended state.

With this issue, idea is from some time back and wasn't ever fully fleshed out (we found no real world use case to base it on). If it is something you'd like and have some time to spare, introducing it yourself is an option (I can guarantee as much that I'm reviewing PR's actively).

As for design - I wouldn't oppose global #[test_case_assertion] marker that could be applied to a global method, which would then be used in every test_case, but local option, like #[test_case::<function_xyz>("foo" => "bar")] may be easier to introduce with how test-case is currently structured.

[luke-biel]

An idea for #73 that came to my mind:

#[test_case(input1 => 1.0)]
#[test_case(input2 => with assert!($.is_nan()))]
fn tested(v: X) -> f64 {
	...
}

We could provide an option to manually map assertions in some cases.
Then, if there's too much repetition and we wanna cover whole test case with our custom assert

fn assert_nan(value: f64) {
	assert!(value.is_nan())
}

#[test_case(input1 => 1.0)]
#[test_case(input2 => use assert_nan)]
fn tested(v: X) -> f64 {
	...
}

which in turn allows:

fn assert_nan(value: f64) {
	assert!(value.is_nan())
}

#[test_case(input2)]
#[test_case_use(assert_nan)]
fn tested(v: X) -> f64 {
	...
}

Still no idea how to apprach global replacement though, but this goes with the spirit of test case in my opinion.
What do you think @frondeus ?

[luke-biel]

I've relaxed a bit requirements on using keyword, thus users can do

    fn wrapped_pretty_assert(expected: u64) -> impl Fn(u64) {
        move |actual: u64| { pretty_assertions::assert_eq!(actual, expected) }
    }

    #[test_case(1 => using wrapped_pretty_assert(1))]
    fn pretty_assertions_usage(input: u64) -> u64 {
        input
    }

I believe this covers all initial work needed to allow custom assertions.
I'm gonna fork this issue so that #[test_case_use(assert_nan)] and global assertions can be done separately.