对于传递给catch_unwind的闭包，可以使用move语义，或者使用#[should_panic]：

pub fn divide(x: &mut i32, y: &mut i32) -> i32 {
    assert!(*y != 0, "Attempted to divide by zero");
    *x / *y
}

#[cfg(test)]
mod tests {
    use super::divide;

    #[test]
    fn test_divide() {
        let mut x = 10;
        let mut y = 2;
        assert_eq!(divide(&mut x, &mut y), 5);
        let mut x = 10;
        let mut y = -2;
        assert_eq!(divide(&mut x, &mut y), -5);

        let result = std::panic::catch_unwind(move || divide(&mut x, &mut 0));
        assert!(result.is_err());
        let err = result.unwrap_err();
        let msg = err.downcast_ref::<&'static str>().unwrap();
        let mssss = "Attempted to divide by zero";
        assert_eq!(msg, &mssss);
    }
    
    #[test]
    #[should_panic(expected = "Attempted to divide by zero")]
    fn test_divide2() {
        let mut x = 10;
        divide(&mut x, &mut 0);
    }   
}

Playground.

可变引用的问题在于它们不是UnwindSafe，这是因为数据可能有不变量，这些不变量会在函数执行过程中暂时中断，然后恢复。如果我们在它们中断时感到恐慌，那么一切都很好--除非我们稍后发现恐慌，在这种情况下，我们可以观察到中断的不变量。
如果你确定你没有任何不变量可以被违反，你可以用AssertUnwindSafe Package 你的闭包：

#[test]
fn test_divide() {
    let mut x = 10;
    let mut y = 2;
    assert_eq!(divide(&mut x, &mut y), 5);
    let mut x = 10;
    let mut y = -2;
    assert_eq!(divide(&mut x, &mut y), -5);

    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| divide(&mut x, &mut 0)));
    assert!(result.is_err());
    let err = result.unwrap_err();
    let msg = err.downcast_ref::<&'static str>().unwrap();
    let mssss = "Attempted to divide by zero";
    assert_eq!(msg, &mssss);
}