test: unwind safety edge cases

Signed-off-by: Mirko Adzic <adzicmirko97@gmail.com>

Author: Mirko-A

tests/unwind_safety.rs

@@ -98,77 +98,81 @@ fn fallible_pin_init(should_error: bool) -> impl PinInit<Counted, Error> {
 #[test]
 fn init_array_from_fn_drops_initialized_prefix_on_panic() {
     const N: usize = 10;
-    const PANIC_AT: usize = 5;
 
-    let _g = LOCK.lock().unwrap();
-    DROPS.store(0, Ordering::SeqCst);
+    for panic_at in [0, 5, N - 1] {
+        let _g = LOCK.lock().unwrap();
+        DROPS.store(0, Ordering::SeqCst);
 
-    let func = AssertUnwindSafe(|| {
-        let init = init_array_from_fn(|i| {
-            let should_panic = i == PANIC_AT;
-            maybe_panicking_init(should_panic)
+        let func = AssertUnwindSafe(|| {
+            let init = init_array_from_fn(|i| {
+                let should_panic = i == panic_at;
+                maybe_panicking_init(should_panic)
+            });
+            let _array: Result<Box<[Counted; N]>, _> = Box::init(init);
         });
-        let _array: Result<Box<[Counted; N]>, _> = Box::init(init);
-    });
-    let result = catch_unwind(func);
+        let result = catch_unwind(func);
 
-    assert!(result.is_err());
-    assert_eq!(DROPS.load(Ordering::SeqCst), PANIC_AT);
+        assert!(result.is_err());
+        assert_eq!(DROPS.load(Ordering::SeqCst), panic_at);
+    }
 }
 
 #[test]
 fn pin_init_array_from_fn_drops_initialized_prefix_on_panic() {
     const N: usize = 10;
-    const PANIC_AT: usize = 5;
 
-    let _g = LOCK.lock().unwrap();
-    DROPS.store(0, Ordering::SeqCst);
+    for panic_at in [0, 5, N - 1] {
+        let _g = LOCK.lock().unwrap();
+        DROPS.store(0, Ordering::SeqCst);
 
-    let func = AssertUnwindSafe(|| {
-        let init = pin_init_array_from_fn(|i| {
-            let should_panic = i == PANIC_AT;
-            maybe_panicking_pin_init(should_panic)
+        let func = AssertUnwindSafe(|| {
+            let init = pin_init_array_from_fn(|i| {
+                let should_panic = i == panic_at;
+                maybe_panicking_pin_init(should_panic)
+            });
+            let _array: Result<Pin<Box<[Counted; N]>>, _> = Box::pin_init(init);
         });
-        let _array: Result<Pin<Box<[Counted; N]>>, _> = Box::pin_init(init);
-    });
-    let result = catch_unwind(func);
+        let result = catch_unwind(func);
 
-    assert!(result.is_err());
-    assert_eq!(DROPS.load(Ordering::SeqCst), PANIC_AT);
+        assert!(result.is_err());
+        assert_eq!(DROPS.load(Ordering::SeqCst), panic_at);
+    }
 }
 
 #[test]
 fn init_array_from_fn_drops_initialized_prefix_on_error() {
     const N: usize = 10;
-    const ERROR_AT: usize = 5;
 
-    let _g = LOCK.lock().unwrap();
-    DROPS.store(0, Ordering::SeqCst);
+    for error_at in [0, 5, N - 1] {
+        let _g = LOCK.lock().unwrap();
+        DROPS.store(0, Ordering::SeqCst);
 
-    let init = init_array_from_fn(|i| {
-        let should_error = i == ERROR_AT;
-        fallible_init(should_error)
-    });
-    let result: Result<Box<[Counted; N]>, _> = Box::try_init(init);
-    assert!(result.is_err());
-    assert_eq!(DROPS.load(Ordering::SeqCst), ERROR_AT);
+        let init = init_array_from_fn(|i| {
+            let should_error = i == error_at;
+            fallible_init(should_error)
+        });
+        let result: Result<Box<[Counted; N]>, _> = Box::try_init(init);
+        assert!(result.is_err());
+        assert_eq!(DROPS.load(Ordering::SeqCst), error_at);
+    }
 }
 
 #[test]
 fn pin_init_array_from_fn_drops_initialized_prefix_on_error() {
     const N: usize = 10;
-    const ERROR_AT: usize = 5;
 
-    let _g = LOCK.lock().unwrap();
-    DROPS.store(0, Ordering::SeqCst);
+    for error_at in [0, 5, N - 1] {
+        let _g = LOCK.lock().unwrap();
+        DROPS.store(0, Ordering::SeqCst);
 
-    let init = pin_init_array_from_fn(|i| {
-        let should_error = i == ERROR_AT;
-        fallible_pin_init(should_error)
-    });
-    let result: Result<Pin<Box<[Counted; N]>>, _> = Box::try_pin_init(init);
-    assert!(result.is_err());
-    assert_eq!(DROPS.load(Ordering::SeqCst), ERROR_AT);
+        let init = pin_init_array_from_fn(|i| {
+            let should_error = i == error_at;
+            fallible_pin_init(should_error)
+        });
+        let result: Result<Pin<Box<[Counted; N]>>, _> = Box::try_pin_init(init);
+        assert!(result.is_err());
+        assert_eq!(DROPS.load(Ordering::SeqCst), error_at);
+    }
 }
 
 #[test]