Move tests from debug_sync to a new submodule

This will allow us to change the module regex match in debug_sync
to make it more robust.

diff --git a/lightning/src/sync/debug_sync.rs b/lightning/src/sync/debug_sync.rs
index b61d1cb55e8cff3143c686c4ad6fbc13427b47d9..ac82475f964b4e38faf17463ce9772a4c053d1cd 100644 (file)
--- a/lightning/src/sync/debug_sync.rs
+++ b/lightning/src/sync/debug_sync.rs
@@ -333,100 +333,3 @@ impl<T> RwLock<T> {
 }
 
 pub type FairRwLock<T> = RwLock<T>;
-
-mod tests {
-       use super::{RwLock, Mutex};
-
-       #[test]
-       #[should_panic]
-       #[cfg(not(feature = "backtrace"))]
-       fn recursive_lock_fail() {
-               let mutex = Mutex::new(());
-               let _a = mutex.lock().unwrap();
-               let _b = mutex.lock().unwrap();
-       }
-
-       #[test]
-       fn recursive_read() {
-               let lock = RwLock::new(());
-               let _a = lock.read().unwrap();
-               let _b = lock.read().unwrap();
-       }
-
-       #[test]
-       #[should_panic]
-       fn lockorder_fail() {
-               let a = Mutex::new(());
-               let b = Mutex::new(());
-               {
-                       let _a = a.lock().unwrap();
-                       let _b = b.lock().unwrap();
-               }
-               {
-                       let _b = b.lock().unwrap();
-                       let _a = a.lock().unwrap();
-               }
-       }
-
-       #[test]
-       #[should_panic]
-       fn write_lockorder_fail() {
-               let a = RwLock::new(());
-               let b = RwLock::new(());
-               {
-                       let _a = a.write().unwrap();
-                       let _b = b.write().unwrap();
-               }
-               {
-                       let _b = b.write().unwrap();
-                       let _a = a.write().unwrap();
-               }
-       }
-
-       #[test]
-       #[should_panic]
-       fn read_lockorder_fail() {
-               let a = RwLock::new(());
-               let b = RwLock::new(());
-               {
-                       let _a = a.read().unwrap();
-                       let _b = b.read().unwrap();
-               }
-               {
-                       let _b = b.read().unwrap();
-                       let _a = a.read().unwrap();
-               }
-       }
-
-       #[test]
-       fn read_recursive_no_lockorder() {
-               // Like the above, but note that no lockorder is implied when we recursively read-lock a
-               // RwLock, causing this to pass just fine.
-               let a = RwLock::new(());
-               let b = RwLock::new(());
-               let _outer = a.read().unwrap();
-               {
-                       let _a = a.read().unwrap();
-                       let _b = b.read().unwrap();
-               }
-               {
-                       let _b = b.read().unwrap();
-                       let _a = a.read().unwrap();
-               }
-       }
-
-       #[test]
-       #[should_panic]
-       fn read_write_lockorder_fail() {
-               let a = RwLock::new(());
-               let b = RwLock::new(());
-               {
-                       let _a = a.write().unwrap();
-                       let _b = b.read().unwrap();
-               }
-               {
-                       let _b = b.read().unwrap();
-                       let _a = a.write().unwrap();
-               }
-       }
-}

diff --git a/lightning/src/sync/mod.rs b/lightning/src/sync/mod.rs
index f5755fc1017be1f282c830cbaad12dd510bce88f..f7226a5fa34eef114d27c6569207dbc68354b950 100644 (file)
--- a/lightning/src/sync/mod.rs
+++ b/lightning/src/sync/mod.rs
@@ -2,6 +2,9 @@
 mod debug_sync;
 #[cfg(all(feature = "std", not(feature = "_bench_unstable"), test))]
 pub use debug_sync::*;
+#[cfg(all(feature = "std", not(feature = "_bench_unstable"), test))]
+// Note that to make debug_sync's regex work this must not contain `debug_string` in the module name
+mod test_lockorder_checks;
 
 #[cfg(all(feature = "std", any(feature = "_bench_unstable", not(test))))]
 pub use ::std::sync::{Arc, Mutex, Condvar, MutexGuard, RwLock, RwLockReadGuard, RwLockWriteGuard};

diff --git a/lightning/src/sync/test_lockorder_checks.rs b/lightning/src/sync/test_lockorder_checks.rs
new file mode 100644 (file)
index 0000000..f9f30e2
--- /dev/null
+++ b/lightning/src/sync/test_lockorder_checks.rs
@@ -0,0 +1,94 @@
+use crate::sync::debug_sync::{RwLock, Mutex};
+
+#[test]
+#[should_panic]
+#[cfg(not(feature = "backtrace"))]
+fn recursive_lock_fail() {
+       let mutex = Mutex::new(());
+       let _a = mutex.lock().unwrap();
+       let _b = mutex.lock().unwrap();
+}
+
+#[test]
+fn recursive_read() {
+       let lock = RwLock::new(());
+       let _a = lock.read().unwrap();
+       let _b = lock.read().unwrap();
+}
+
+#[test]
+#[should_panic]
+fn lockorder_fail() {
+       let a = Mutex::new(());
+       let b = Mutex::new(());
+       {
+               let _a = a.lock().unwrap();
+               let _b = b.lock().unwrap();
+       }
+       {
+               let _b = b.lock().unwrap();
+               let _a = a.lock().unwrap();
+       }
+}
+
+#[test]
+#[should_panic]
+fn write_lockorder_fail() {
+       let a = RwLock::new(());
+       let b = RwLock::new(());
+       {
+               let _a = a.write().unwrap();
+               let _b = b.write().unwrap();
+       }
+       {
+               let _b = b.write().unwrap();
+               let _a = a.write().unwrap();
+       }
+}
+
+#[test]
+#[should_panic]
+fn read_lockorder_fail() {
+       let a = RwLock::new(());
+       let b = RwLock::new(());
+       {
+               let _a = a.read().unwrap();
+               let _b = b.read().unwrap();
+       }
+       {
+               let _b = b.read().unwrap();
+               let _a = a.read().unwrap();
+       }
+}
+
+#[test]
+fn read_recursive_no_lockorder() {
+       // Like the above, but note that no lockorder is implied when we recursively read-lock a
+       // RwLock, causing this to pass just fine.
+       let a = RwLock::new(());
+       let b = RwLock::new(());
+       let _outer = a.read().unwrap();
+       {
+               let _a = a.read().unwrap();
+               let _b = b.read().unwrap();
+       }
+       {
+               let _b = b.read().unwrap();
+               let _a = a.read().unwrap();
+       }
+}
+
+#[test]
+#[should_panic]
+fn read_write_lockorder_fail() {
+       let a = RwLock::new(());
+       let b = RwLock::new(());
+       {
+               let _a = a.write().unwrap();
+               let _b = b.read().unwrap();
+       }
+       {
+               let _b = b.read().unwrap();
+               let _a = a.write().unwrap();
+       }
+}