move nonpoison_and_poison_unwrap_test macro to lib.rs

This commit moves the duplicating test macro for poison and nonpoison
locks into the parent module. Since it is generic for all locks (either
it calls `unwrap` or it doesn't), we can use it for all poison/nonpoison
lock tests.

Author: connortsui20

library/std/tests/sync/lib.rs

@@ -9,7 +9,7 @@
 #![feature(sync_nonpoison)]
 #![feature(nonpoison_mutex)]
 #![allow(internal_features)]
-#![feature(macro_metavar_expr_concat)] // For the mutex test macros.
+#![feature(macro_metavar_expr_concat)] // For concatenating identifiers in macros.
 
 mod barrier;
 mod condvar;
@@ -32,3 +32,50 @@ mod rwlock;
 
 #[path = "../common/mod.rs"]
 mod common;
+
+// Generates two test cases for both the poison and nonpoison locks.
+//
+// To write a test that uses both `poison` and `nonpoison` locks, simply call the macro
+// `maybe_unwrap!(...)` on the result of `mutex.lock()`, `rwlock.read()`, etc. For example, you
+// would call `maybe_unwrap!(mutex.lock())` instead of `mutex.lock().unwrap()`.
+//
+// For the `poison` types, it will simply unwrap the `Result` (usually this is a form of
+// `LockResult`, but it could also be other kinds of results). For the `nonpoison` types, it is a
+// no-op.
+//
+// The `poison` test will have the same name, but with a suffix of `_unwrap_poisoned`.
+#[macro_export]
+macro_rules! nonpoison_and_poison_unwrap_test {
+    (
+        name: $name:ident,
+        test_body: {$($test_body:tt)*}
+    ) => {
+        // Creates the nonpoison test.
+        #[test]
+        fn $name() {
+            #[allow(unused_imports)]
+            use ::std::sync::nonpoison::*;
+
+            #[allow(unused_macros)]
+            macro_rules! maybe_unwrap {
+                ($e:expr) => { $e };
+            }
+
+            $($test_body)*
+        }
+
+        // Creates the poison test with the suffix `_unwrap_poisoned`.
+        #[test]
+        fn ${concat($name, _unwrap_poisoned)}() {
+            #[allow(unused_imports)]
+            use ::std::sync::poison::*;
+
+            #[allow(unused_macros)]
+            macro_rules! maybe_unwrap {
+                ($e:expr) => { ::std::result::Result::unwrap($e) };
+            }
+
+            $($test_body)*
+        }
+    }
+}

library/std/tests/sync/mutex.rs

@@ -6,50 +6,7 @@ use std::sync::mpsc::channel;
 use std::sync::{Arc, Condvar, MappedMutexGuard, Mutex, MutexGuard, TryLockError};
 use std::{hint, mem, thread};
 
-// Generates two test cases for both the poison and nonpoison locks.
-//
-// To write a test that uses both `poison::Mutex` and `nonpoison::Mutex`, simply call the macro
-// `maybe_unwrap!(...)` on the result of `mutex.lock()`. For the `poison::Mutex`, it will unwrap the
-// `Result` (usually `LockResult`, but it could be other kinds of results), but for the
-// `nonpoison::Mutex` it will do nothing.
-//
-// The `poison` test will have the same name, but with a suffix of `_unwrap_poisoned`.
-//
-// See some of the tests below for examples.
-macro_rules! nonpoison_and_poison_unwrap_test {
-    (
-        name: $name:ident,
-        test_body: {$($test_body:tt)*}
-    ) => {
-        // Creates the nonpoison test.
-        #[test]
-        fn $name() {
-            #[allow(unused_imports)]
-            use ::std::sync::nonpoison::{Mutex, MappedMutexGuard, MutexGuard};
-
-            #[allow(unused_macros)]
-            macro_rules! maybe_unwrap {
-                ($e:expr) => { $e };
-            }
-
-            $($test_body)*
-        }
-
-        // Creates the poison test with the suffix `_unwrap_poisoned`.
-        #[test]
-        fn ${concat($name, _unwrap_poisoned)}() {
-            #[allow(unused_imports)]
-            use ::std::sync::{Mutex, MappedMutexGuard, MutexGuard};
-
-            #[allow(unused_macros)]
-            macro_rules! maybe_unwrap {
-                ($e:expr) => { Result::unwrap($e) };
-            }
-
-            $($test_body)*
-        }
-    }
-}
+use super::nonpoison_and_poison_unwrap_test;
 
 nonpoison_and_poison_unwrap_test!(
     name: smoke,
@@ -211,6 +168,8 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
+// FIXME(nonpoison_condvar): Move this to the `condvar.rs` test file once `nonpoison::condvar` gets
+// implemented.
 #[test]
 fn test_mutex_arc_condvar() {
     struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
@@ -290,6 +249,7 @@ nonpoison_and_poison_unwrap_test!(
     }
 );
 
+/// Creates a mutex that is immediately poisoned.
 fn new_poisoned_mutex<T>(value: T) -> Mutex<T> {
     let mutex = Mutex::new(value);