Ignore tests that require unwinding on targets that don't support it

Author: Jules-Bertholet

library/alloc/src/collections/binary_heap/tests.rs

@@ -290,6 +290,7 @@ fn test_drain_sorted() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drain_sorted_leak() {
     static DROPS: AtomicU32 = AtomicU32::new(0);
 
@@ -411,9 +412,8 @@ fn test_retain() {
 // even if the order might not be correct.
 //
 // Destructors must be called exactly once per element.
-// FIXME: re-enable emscripten once it can unwind again
 #[test]
-#[cfg(not(target_os = "emscripten"))]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn panic_safe() {
     use rand::{seq::SliceRandom, thread_rng};
     use std::cmp;

library/alloc/src/collections/btree/map/tests.rs

@@ -1122,6 +1122,7 @@ mod test_drain_filter {
     }
 
     #[test]
+    #[cfg_attr(not(panic = "unwind"), should_panic)]
     fn drop_panic_leak() {
         let a = CrashTestDummy::new(0);
         let b = CrashTestDummy::new(1);
@@ -1142,6 +1143,7 @@ mod test_drain_filter {
     }
 
     #[test]
+    #[cfg_attr(not(panic = "unwind"), should_panic)]
     fn pred_panic_leak() {
         let a = CrashTestDummy::new(0);
         let b = CrashTestDummy::new(1);
@@ -1168,6 +1170,7 @@ mod test_drain_filter {
 
     // Same as above, but attempt to use the iterator again after the panic in the predicate
     #[test]
+    #[cfg_attr(not(panic = "unwind"), should_panic)]
     fn pred_panic_reuse() {
         let a = CrashTestDummy::new(0);
         let b = CrashTestDummy::new(1);
@@ -1416,6 +1419,7 @@ fn test_clear() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_clear_drop_panic_leak() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);
@@ -1507,11 +1511,13 @@ fn test_clone_panic_leak(size: usize) {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_clone_panic_leak_height_0() {
     test_clone_panic_leak(3)
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_clone_panic_leak_height_1() {
     test_clone_panic_leak(MIN_INSERTS_HEIGHT_1)
 }
@@ -2066,6 +2072,7 @@ create_append_test!(test_append_239, 239);
 create_append_test!(test_append_1700, 1700);
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_append_drop_leak() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);
@@ -2207,6 +2214,7 @@ fn test_split_off_large_random_sorted() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_into_iter_drop_leak_height_0() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);
@@ -2230,6 +2238,7 @@ fn test_into_iter_drop_leak_height_0() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_into_iter_drop_leak_height_1() {
     let size = MIN_INSERTS_HEIGHT_1;
     for panic_point in vec![0, 1, size - 2, size - 1] {

library/alloc/src/collections/btree/set/tests.rs

@@ -377,6 +377,7 @@ fn test_drain_filter() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drain_filter_drop_panic_leak() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);
@@ -397,6 +398,7 @@ fn test_drain_filter_drop_panic_leak() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drain_filter_pred_panic_leak() {
     let a = CrashTestDummy::new(0);
     let b = CrashTestDummy::new(1);

library/alloc/src/collections/linked_list/tests.rs

@@ -983,6 +983,7 @@ fn drain_filter_complex() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn drain_filter_drop_panic_leak() {
     static mut DROPS: i32 = 0;
 
@@ -1017,6 +1018,7 @@ fn drain_filter_drop_panic_leak() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn drain_filter_pred_panic_leak() {
     static mut DROPS: i32 = 0;
 
@@ -1123,6 +1125,7 @@ fn test_drop_clear() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drop_panic() {
     static mut DROPS: i32 = 0;
 

library/alloc/tests/slice.rs

@@ -1539,8 +1539,8 @@ fn test_box_slice_clone() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 #[allow(unused_must_use)] // here, we care about the side effects of `.clone()`
-#[cfg_attr(target_os = "emscripten", ignore)]
 fn test_box_slice_clone_panics() {
     use std::sync::atomic::{AtomicUsize, Ordering};
     use std::sync::Arc;
@@ -1782,6 +1782,7 @@ thread_local!(static SILENCE_PANIC: Cell<bool> = Cell::new(false));
 
 #[test]
 #[cfg_attr(target_os = "emscripten", ignore)] // no threads
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn panic_safe() {
     panic::update_hook(move |prev, info| {
         if !SILENCE_PANIC.with(|s| s.get()) {

library/alloc/tests/string.rs

@@ -411,7 +411,11 @@ fn test_retain() {
 
     s.retain(|_| false);
     assert_eq!(s, "");
+}
 
+#[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
+fn test_retain_panic() {
     let mut s = String::from("0è0");
     let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| {
         let mut count = 0;

library/alloc/tests/vec.rs

@@ -293,6 +293,7 @@ fn test_retain() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_retain_pred_panic_with_hole() {
     let v = (0..5).map(Rc::new).collect::<Vec<_>>();
     catch_unwind(AssertUnwindSafe(|| {
@@ -310,6 +311,7 @@ fn test_retain_pred_panic_with_hole() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_retain_pred_panic_no_hole() {
     let v = (0..5).map(Rc::new).collect::<Vec<_>>();
     catch_unwind(AssertUnwindSafe(|| {
@@ -325,6 +327,7 @@ fn test_retain_pred_panic_no_hole() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_retain_drop_panic() {
     struct Wrap(Rc<i32>);
 
@@ -756,6 +759,7 @@ fn test_drain_end_overflow() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drain_leak() {
     static mut DROPS: i32 = 0;
 
@@ -949,6 +953,7 @@ fn test_into_iter_clone() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_into_iter_leak() {
     static mut DROPS: i32 = 0;
 
@@ -1076,6 +1081,7 @@ fn test_from_iter_specialization_head_tail_drop() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_from_iter_specialization_panic_during_iteration_drops() {
     let drop_count: Vec<_> = (0..=2).map(|_| Rc::new(())).collect();
     let src: Vec<_> = drop_count.iter().cloned().collect();
@@ -1100,6 +1106,7 @@ fn test_from_iter_specialization_panic_during_iteration_drops() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_from_iter_specialization_panic_during_drop_leaks() {
     static mut DROP_COUNTER: usize = 0;
 
@@ -1367,9 +1374,8 @@ fn drain_filter_complex() {
     }
 }
 
-// FIXME: re-enable emscripten once it can unwind again
 #[test]
-#[cfg(not(target_os = "emscripten"))]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn drain_filter_consumed_panic() {
     use std::rc::Rc;
     use std::sync::Mutex;
@@ -1419,9 +1425,8 @@ fn drain_filter_consumed_panic() {
     }
 }
 
-// FIXME: Re-enable emscripten once it can catch panics
 #[test]
-#[cfg(not(target_os = "emscripten"))]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn drain_filter_unconsumed_panic() {
     use std::rc::Rc;
     use std::sync::Mutex;
@@ -2314,6 +2319,7 @@ fn test_vec_dedup() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_vec_dedup_panicking() {
     #[derive(Debug)]
     struct Panic<'a> {
@@ -2370,6 +2376,7 @@ fn test_vec_dedup_panicking() {
 
 // Regression test for issue #82533
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_extend_from_within_panicing_clone() {
     struct Panic<'dc> {
         drop_count: &'dc AtomicU32,

library/alloc/tests/vec_deque.rs

@@ -726,6 +726,7 @@ fn test_drop_clear() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drop_panic() {
     static mut DROPS: i32 = 0;
 
@@ -1620,6 +1621,7 @@ fn test_try_rfold_moves_iter() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn truncate_leak() {
     static mut DROPS: i32 = 0;
 
@@ -1653,6 +1655,7 @@ fn truncate_leak() {
 }
 
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_drain_leak() {
     static mut DROPS: i32 = 0;
 

library/core/tests/array.rs

@@ -256,14 +256,8 @@ fn iterator_drops() {
     assert_eq!(i.get(), 5);
 }
 
-// This test does not work on targets without panic=unwind support.
-// To work around this problem, test is marked is should_panic, so it will
-// be automagically skipped on unsuitable targets, such as
-// wasm32-unknown-unknown.
-//
-// It means that we use panic for indicating success.
-#[test]
-#[should_panic(expected = "test succeeded")]
+#[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn array_default_impl_avoids_leaks_on_panic() {
     use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
     static COUNTER: AtomicUsize = AtomicUsize::new(0);
@@ -295,7 +289,6 @@ fn array_default_impl_avoids_leaks_on_panic() {
     assert_eq!(*panic_msg, "bomb limit exceeded");
     // check that all bombs are successfully dropped
     assert_eq!(COUNTER.load(Relaxed), 0);
-    panic!("test succeeded")
 }
 
 #[test]
@@ -316,9 +309,8 @@ fn array_map() {
     assert_eq!(b, [1, 2, 3]);
 }
 
-// See note on above test for why `should_panic` is used.
 #[test]
-#[should_panic(expected = "test succeeded")]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn array_map_drop_safety() {
     static DROPPED: AtomicUsize = AtomicUsize::new(0);
     struct DropCounter;
@@ -340,7 +332,6 @@ fn array_map_drop_safety() {
     });
     assert!(success.is_err());
     assert_eq!(DROPPED.load(Ordering::SeqCst), num_to_create);
-    panic!("test succeeded")
 }
 
 #[test]
@@ -392,8 +383,8 @@ fn array_try_from_fn() {
     assert_eq!(another_array, Err(SomeError::Foo));
 }
 
-#[cfg(not(panic = "abort"))]
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn array_try_from_fn_drops_inserted_elements_on_err() {
     static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
 
@@ -416,8 +407,8 @@ fn array_try_from_fn_drops_inserted_elements_on_err() {
     assert_eq!(DROP_COUNTER.load(Ordering::SeqCst), 2);
 }
 
-#[cfg(not(panic = "abort"))]
 #[test]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn array_try_from_fn_drops_inserted_elements_on_panic() {
     static DROP_COUNTER: AtomicUsize = AtomicUsize::new(0);
 
@@ -440,7 +431,6 @@ fn array_try_from_fn_drops_inserted_elements_on_panic() {
     assert_eq!(DROP_COUNTER.load(Ordering::SeqCst), 2);
 }
 
-#[cfg(not(panic = "abort"))]
 // https://stackoverflow.com/a/59211505
 fn catch_unwind_silent<F, R>(f: F) -> std::thread::Result<R>
 where

library/core/tests/iter/adapters/zip.rs

@@ -233,7 +233,7 @@ fn test_zip_trusted_random_access_composition() {
 }
 
 #[test]
-#[cfg(panic = "unwind")]
+#[cfg_attr(not(panic = "unwind"), should_panic)]
 fn test_zip_trusted_random_access_next_back_drop() {
     use std::panic::catch_unwind;
     use std::panic::AssertUnwindSafe;