suitecase 0.0.5

The structured test toolkit. A sync Rust crate for named cases, optional suite and per-case hooks, and macros so each case appears in cargo test—without a custom harness or DSL.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Assertions about whether code panics, using [`std::panic::catch_unwind`].

use std::panic::{AssertUnwindSafe, catch_unwind};

/// Asserts that invoking `f` unwinds with a panic.
///
/// # Panics
///
/// Panics when `f` returns normally.
///
/// # Examples
///
/// ```
/// use suitecase::assert::panics;
///
/// panics(|| panic!("boom"));
/// ```
#[track_caller]
pub fn panics(f: impl FnOnce()) {
    let r = catch_unwind(AssertUnwindSafe(f));
    if r.is_ok() {
        panic!("assertion failed: `panics`: expected closure to panic");
    }
}

/// Asserts that invoking `f` completes without panicking.
///
/// # Panics
///
/// Panics when `f` unwinds.
///
/// # Examples
///
/// ```
/// use suitecase::assert::not_panics;
///
/// not_panics(|| {
///     let _ = 1 + 1;
/// });
/// ```
#[track_caller]
pub fn not_panics(f: impl FnOnce()) {
    let r = catch_unwind(AssertUnwindSafe(f));
    if let Err(payload) = r {
        panic!(
            "assertion failed: `not_panics`: closure panicked: {:?}",
            panic_payload_to_string(payload)
        );
    }
}

fn panic_payload_to_string(payload: Box<dyn std::any::Any + Send>) -> String {
    payload
        .downcast_ref::<&'static str>()
        .map(|s| (*s).to_string())
        .or_else(|| payload.downcast_ref::<String>().cloned())
        .unwrap_or_else(|| "(opaque panic payload)".to_string())
}

/// Asserts that `f` panics and the panic message contains `needle`.
///
/// # Panics
///
/// Panics when `f` does not panic, or the message does not contain `needle`.
///
/// # Examples
///
/// ```
/// use suitecase::assert::panics_with_substring;
///
/// panics_with_substring(|| panic!("expected token"), "token");
/// ```
#[track_caller]
pub fn panics_with_substring(f: impl FnOnce(), needle: &str) {
    let r = catch_unwind(AssertUnwindSafe(f));
    match r {
        Ok(()) => panic!("assertion failed: `panics_with_substring`: expected panic"),
        Err(payload) => {
            let s = panic_payload_to_string(payload);
            if !s.contains(needle) {
                panic!(
                    "assertion failed: `panics_with_substring`\n  needle: `{needle}`\n message: `{s}`"
                );
            }
        }
    }
}