Trait DecorateTest

pub trait DecorateTest<R>:
    RefUnwindSafe
    + Send
    + Sync
    + 'static {
    // Required method
    fn decorate_and_test<F: TestFn<R>>(&'static self, test_fn: F) -> R;
}

Test decorator.

See module docs for the extended description.

Examples

The following decorator implements a #[should_panic] analogue for errors.

use test_casing::decorators::{DecorateTest, TestFn};

#[derive(Debug, Clone, Copy)]
pub struct ShouldError(pub &'static str);

impl<E: ToString> DecorateTest<Result<(), E>> for ShouldError {
    fn decorate_and_test<F: TestFn<Result<(), E>>>(
        &self,
        test_fn: F,
    ) -> Result<(), E> {
        let Err(err) = test_fn() else {
            panic!("Expected test to error, but it completed successfully");
        };
        let err = err.to_string();
        if err.contains(self.0) {
            Ok(())
        } else {
            panic!(
                "Expected error message to contain `{}`, but it was: {err}",
                self.0
            );
        }
    }
}

// Usage:
#[test]
#[decorate(ShouldError("oops"))]
fn test_with_an_error() -> Result<(), Box<dyn Error>> {
    Err("oops, this test failed".into())
}

Required Methods

fn decorate_and_test<F: TestFn<R>>(&'static self, test_fn: F) -> R

Decorates the provided test function and runs the test.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<R, A> DecorateTest<R> for (A,)

where A: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B> DecorateTest<R> for (A, B)

where A: DecorateTest<R>, B: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C> DecorateTest<R> for (A, B, C)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C, D> DecorateTest<R> for (A, B, C, D)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>, D: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C, D, E> DecorateTest<R> for (A, B, C, D, E)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>, D: DecorateTest<R>, E: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C, D, E, F> DecorateTest<R> for (A, B, C, D, E, F)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>, D: DecorateTest<R>, E: DecorateTest<R>, F: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C, D, E, F, G> DecorateTest<R> for (A, B, C, D, E, F, G)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>, D: DecorateTest<R>, E: DecorateTest<R>, F: DecorateTest<R>, G: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, A, B, C, D, E, F, G, H> DecorateTest<R> for (A, B, C, D, E, F, G, H)

where A: DecorateTest<R>, B: DecorateTest<R>, C: DecorateTest<R>, D: DecorateTest<R>, E: DecorateTest<R>, F: DecorateTest<R>, G: DecorateTest<R>, H: DecorateTest<R>,

fn decorate_and_test<Fn: TestFn<R>>(&'static self, test_fn: Fn) -> R

impl<R, T: DecorateTest<R>> DecorateTest<R> for &'static T

fn decorate_and_test<F: TestFn<R>>(&'static self, test_fn: F) -> R

Implementors

impl DecorateTest<()> for Retry

impl DecorateTest<()> for Sequence

impl<E: 'static> DecorateTest<Result<(), E>> for Sequence

impl<E: Display + 'static> DecorateTest<Result<(), E>> for RetryErrors<E>

impl<E: Display> DecorateTest<Result<(), E>> for Retry

impl<R: Send + 'static> DecorateTest<R> for Timeout