Cope better with asserts inside parallel blocks

serial_test/Cargo.toml

@@ -17,9 +17,11 @@ serial_test_derive = { version = "~0.7.0", path = "../serial_test_derive" }
 fslock = {version = "0.2", optional = true}
 document-features = {version = "0.2", optional=true}
 log = "0.4"
+futures = {version = "^0.3", default_features = false, features = ["executor"] }
 
 [dev-dependencies]
 itertools = "0.10"
+tokio = { version = "^1.17", features = ["macros", "rt"] }
 
 [features]
 default = []

serial_test/src/code_lock.rs

@@ -30,6 +30,16 @@ impl UniqueReentrantMutex {
     pub(crate) fn end_parallel(&self) {
         self.locks.end_parallel();
     }
+
+    #[cfg(test)]
+    pub fn parallel_count(&self) -> u32 {
+        self.locks.parallel_count()
+    }
+
+    #[cfg(test)]
+    pub fn is_locked(&self) -> bool {
+        self.locks.is_locked()
+    }
 }
 
 lazy_static! {

serial_test/src/parallel_code_lock.rs

@@ -1,7 +1,8 @@
 #![allow(clippy::await_holding_lock)]
 
 use crate::code_lock::{check_new_key, LOCKS};
-use std::ops::Deref;
+use futures::FutureExt;
+use std::{ops::Deref, panic};
 
 #[doc(hidden)]
 pub fn local_parallel_core_with_return<E>(
@@ -12,9 +13,14 @@ pub fn local_parallel_core_with_return<E>(
 
     let unlock = LOCKS.read_recursive();
     unlock.deref()[name].start_parallel();
-    let ret = function();
+    let res = panic::catch_unwind(function);
     unlock.deref()[name].end_parallel();
-    ret
+    match res {
+        Ok(ret) => ret,
+        Err(err) => {
+            panic::resume_unwind(err);
+        }
+    }
 }
 
 #[doc(hidden)]
@@ -23,30 +29,137 @@ pub fn local_parallel_core(name: &str, function: fn()) {
 
     let unlock = LOCKS.read_recursive();
     unlock.deref()[name].start_parallel();
-    function();
+    let res = panic::catch_unwind(|| {
+        function();
+    });
     unlock.deref()[name].end_parallel();
+    if let Err(err) = res {
+        panic::resume_unwind(err);
+    }
 }
 
 #[doc(hidden)]
 pub async fn local_async_parallel_core_with_return<E>(
     name: &str,
-    fut: impl std::future::Future<Output = Result<(), E>>,
+    fut: impl std::future::Future<Output = Result<(), E>> + panic::UnwindSafe,
 ) -> Result<(), E> {
     check_new_key(name);
 
     let unlock = LOCKS.read_recursive();
     unlock.deref()[name].start_parallel();
-    let ret = fut.await;
+    let res = fut.catch_unwind().await;
     unlock.deref()[name].end_parallel();
-    ret
+    match res {
+        Ok(ret) => ret,
+        Err(err) => {
+            panic::resume_unwind(err);
+        }
+    }
 }
 
 #[doc(hidden)]
-pub async fn local_async_parallel_core(name: &str, fut: impl std::future::Future<Output = ()>) {
+pub async fn local_async_parallel_core(
+    name: &str,
+    fut: impl std::future::Future<Output = ()> + panic::UnwindSafe,
+) {
     check_new_key(name);
 
     let unlock = LOCKS.read_recursive();
     unlock.deref()[name].start_parallel();
-    fut.await;
+    let res = fut.catch_unwind().await;
     unlock.deref()[name].end_parallel();
+    if let Err(err) = res {
+        panic::resume_unwind(err);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        code_lock::LOCKS, local_async_parallel_core, local_async_parallel_core_with_return,
+        local_parallel_core, local_parallel_core_with_return,
+    };
+    use std::{io::Error, ops::Deref, panic};
+
+    #[test]
+    fn unlock_on_assert_sync_without_return() {
+        let _ = panic::catch_unwind(|| {
+            local_parallel_core("unlock_on_assert_sync_without_return", || {
+                assert!(false);
+            })
+        });
+        let unlock = LOCKS.read_recursive();
+        assert_eq!(
+            unlock.deref()["unlock_on_assert_sync_without_return"].parallel_count(),
+            0
+        );
+    }
+
+    #[test]
+    fn unlock_on_assert_sync_with_return() {
+        let _ = panic::catch_unwind(|| {
+            local_parallel_core_with_return(
+                "unlock_on_assert_sync_with_return",
+                || -> Result<(), Error> {
+                    assert!(false);
+                    Ok(())
+                },
+            )
+        });
+        let unlock = LOCKS.read_recursive();
+        assert_eq!(
+            unlock.deref()["unlock_on_assert_sync_with_return"].parallel_count(),
+            0
+        );
+    }
+
+    #[tokio::test]
+    async fn unlock_on_assert_async_without_return() {
+        async fn demo_assert() {
+            assert!(false);
+        }
+        async fn call_serial_test_fn() {
+            local_async_parallel_core("unlock_on_assert_async_without_return", demo_assert()).await
+        }
+        // as per https://stackoverflow.com/a/66529014/320546
+        let _ = panic::catch_unwind(|| {
+            let handle = tokio::runtime::Handle::current();
+            let _enter_guard = handle.enter();
+            futures::executor::block_on(call_serial_test_fn());
+        });
+        let unlock = LOCKS.read_recursive();
+        assert_eq!(
+            unlock.deref()["unlock_on_assert_async_without_return"].parallel_count(),
+            0
+        );
+    }
+
+    #[tokio::test]
+    async fn unlock_on_assert_async_with_return() {
+        async fn demo_assert() -> Result<(), Error> {
+            assert!(false);
+            Ok(())
+        }
+
+        #[allow(unused_must_use)]
+        async fn call_serial_test_fn() {
+            local_async_parallel_core_with_return(
+                "unlock_on_assert_async_with_return",
+                demo_assert(),
+            )
+            .await;
+        }
+
+        // as per https://stackoverflow.com/a/66529014/320546
+        let _ = panic::catch_unwind(|| {
+            let handle = tokio::runtime::Handle::current();
+            let _enter_guard = handle.enter();
+            futures::executor::block_on(call_serial_test_fn());
+        });
+        let unlock = LOCKS.read_recursive();
+        assert_eq!(
+            unlock.deref()["unlock_on_assert_async_with_return"].parallel_count(),
+            0
+        );
+    }
 }

serial_test/src/rwlock.rs

@@ -39,6 +39,11 @@ impl Locks {
         }
     }
 
+    #[cfg(test)]
+    pub fn is_locked(&self) -> bool {
+        self.arc.serial.is_locked()
+    }
+
     pub fn serial(&self) -> MutexGuardWrapper {
         let mut lock_state = self.arc.mutex.lock();
         loop {
@@ -88,4 +93,10 @@ impl Locks {
         drop(lock_state);
         self.arc.condvar.notify_one();
     }
+
+    #[cfg(test)]
+    pub fn parallel_count(&self) -> u32 {
+        let lock_state = self.arc.mutex.lock();
+        lock_state.parallels
+    }
 }

serial_test/src/serial_code_lock.rs

@@ -51,6 +51,7 @@ pub async fn local_async_serial_core(name: &str, fut: impl std::future::Future<O
 
 #[cfg(test)]
 mod tests {
+    use super::local_serial_core;
     use crate::code_lock::{check_new_key, wait_duration, LOCKS};
     use itertools::Itertools;
     use parking_lot::RwLock;
@@ -100,4 +101,15 @@ mod tests {
         println!("{:?}", ptrs_read_lock);
         assert_eq!(ptrs_read_lock.iter().unique().count(), 1);
     }
+
+    #[test]
+    fn unlock_on_assert() {
+        let _ = std::panic::catch_unwind(|| {
+            local_serial_core("assert", || {
+                assert!(false);
+            })
+        });
+        let unlock = LOCKS.read_recursive();
+        assert!(!unlock.deref()["assert"].is_locked());
+    }
 }