22 files changed, 101 insertions, 99 deletions

diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index be6c2aad871..7648dc141d8 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -131,6 +131,10 @@ path = "tests/pipe_subprocess.rs"
 harness = false
 
 [[test]]
+name = "sync"
+path = "tests/sync/lib.rs"
+
+[[test]]
 name = "floats"
 path = "tests/floats/lib.rs"
 
diff --git a/library/std/src/sync/barrier.rs b/library/std/src/sync/barrier.rs
index 862753e4765..067ff66d9af 100644
--- a/library/std/src/sync/barrier.rs
+++ b/library/std/src/sync/barrier.rs
@@ -1,6 +1,3 @@
-#[cfg(test)]
-mod tests;
-
 use crate::fmt;
 // FIXME(nonpoison_mutex,nonpoison_condvar): switch to nonpoison versions once they are available
 use crate::sync::{Condvar, Mutex};
diff --git a/library/std/src/sync/lazy_lock.rs b/library/std/src/sync/lazy_lock.rs
index 98c83d8d326..78cf8841efe 100644
--- a/library/std/src/sync/lazy_lock.rs
+++ b/library/std/src/sync/lazy_lock.rs
@@ -350,6 +350,3 @@ unsafe impl<T: Sync + Send, F: Send> Sync for LazyLock<T, F> {}
 impl<T: RefUnwindSafe + UnwindSafe, F: UnwindSafe> RefUnwindSafe for LazyLock<T, F> {}
 #[stable(feature = "lazy_cell", since = "1.80.0")]
 impl<T: UnwindSafe, F: UnwindSafe> UnwindSafe for LazyLock<T, F> {}
-
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/sync/mpsc/mod.rs b/library/std/src/sync/mpsc.rs
index c86b546e011..f942937c14d 100644
--- a/library/std/src/sync/mpsc/mod.rs
+++ b/library/std/src/sync/mpsc.rs
@@ -137,12 +137,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod sync_tests;
-
 // MPSC channels are built as a wrapper around MPMC channels, which
 // were ported from the `crossbeam-channel` crate. MPMC channels are
 // not exposed publicly, but if you are curious about the implementation,
@@ -737,9 +731,10 @@ impl<T> SyncSender<T> {
     // Attempts to send for a value on this receiver, returning an error if the
     // corresponding channel has hung up, or if it waits more than `timeout`.
     //
-    // This method is currently private and only used for tests.
-    #[allow(unused)]
-    fn send_timeout(&self, t: T, timeout: Duration) -> Result<(), mpmc::SendTimeoutError<T>> {
+    // This method is currently only used for tests.
+    #[unstable(issue = "none", feature = "std_internals")]
+    #[doc(hidden)]
+    pub fn send_timeout(&self, t: T, timeout: Duration) -> Result<(), mpmc::SendTimeoutError<T>> {
         self.inner.send_timeout(t, timeout)
     }
 }
diff --git a/library/std/src/sync/once_lock.rs b/library/std/src/sync/once_lock.rs
index 49f2dafd8fd..f6e4b34a13a 100644
--- a/library/std/src/sync/once_lock.rs
+++ b/library/std/src/sync/once_lock.rs
@@ -676,6 +676,3 @@ unsafe impl<#[may_dangle] T> Drop for OnceLock<T> {
         }
     }
 }
-
-#[cfg(test)]
-mod tests;
diff --git a/library/std/src/sync/poison/condvar.rs b/library/std/src/sync/poison/condvar.rs
index a6e2389c93b..7f0f3f652bc 100644
--- a/library/std/src/sync/poison/condvar.rs
+++ b/library/std/src/sync/poison/condvar.rs
@@ -1,6 +1,3 @@
-#[cfg(test)]
-mod tests;
-
 use crate::fmt;
 use crate::sync::poison::{self, LockResult, MutexGuard, PoisonError, mutex};
 use crate::sys::sync as sys;
diff --git a/library/std/src/sync/poison/mutex.rs b/library/std/src/sync/poison/mutex.rs
index 01ef71a187f..0a5ad561926 100644
--- a/library/std/src/sync/poison/mutex.rs
+++ b/library/std/src/sync/poison/mutex.rs
@@ -1,6 +1,3 @@
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
 use crate::cell::UnsafeCell;
 use crate::fmt;
 use crate::marker::PhantomData;
diff --git a/library/std/src/sync/poison/once.rs b/library/std/src/sync/poison/once.rs
index 27db4b634fb..f78d88ac6d8 100644
--- a/library/std/src/sync/poison/once.rs
+++ b/library/std/src/sync/poison/once.rs
@@ -3,9 +3,6 @@
 //! This primitive is meant to be used to run one-time initialization. An
 //! example use case would be for initializing an FFI library.
 
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
 use crate::fmt;
 use crate::panic::{RefUnwindSafe, UnwindSafe};
 use crate::sys::sync as sys;
diff --git a/library/std/src/sync/poison/rwlock.rs b/library/std/src/sync/poison/rwlock.rs
index 1519baf99a8..f9d9321f5f2 100644
--- a/library/std/src/sync/poison/rwlock.rs
+++ b/library/std/src/sync/poison/rwlock.rs
@@ -1,6 +1,3 @@
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
 use crate::cell::UnsafeCell;
 use crate::fmt;
 use crate::marker::PhantomData;
diff --git a/library/std/src/sync/reentrant_lock.rs b/library/std/src/sync/reentrant_lock.rs
index 0140e0d2129..e009eb410ef 100644
--- a/library/std/src/sync/reentrant_lock.rs
+++ b/library/std/src/sync/reentrant_lock.rs
@@ -1,6 +1,3 @@
-#[cfg(all(test, not(any(target_os = "emscripten", target_os = "wasi"))))]
-mod tests;
-
 use cfg_if::cfg_if;
 
 use crate::cell::UnsafeCell;
@@ -324,7 +321,10 @@ impl<T: ?Sized> ReentrantLock<T> {
     /// Otherwise, an RAII guard is returned.
     ///
     /// This function does not block.
-    pub(crate) fn try_lock(&self) -> Option<ReentrantLockGuard<'_, T>> {
+    // FIXME maybe make it a public part of the API?
+    #[unstable(issue = "none", feature = "std_internals")]
+    #[doc(hidden)]
+    pub fn try_lock(&self) -> Option<ReentrantLockGuard<'_, T>> {
         let this_thread = current_id();
         // Safety: We only touch lock_count when we own the inner mutex.
         // Additionally, we only call `self.owner.set()` while holding
diff --git a/library/std/src/sync/barrier/tests.rs b/library/std/tests/sync/barrier.rs
index 0fbcd998812..8aefff9d507 100644
--- a/library/std/src/sync/barrier/tests.rs
+++ b/library/std/tests/sync/barrier.rs
@@ -1,6 +1,6 @@
-use crate::sync::mpsc::{TryRecvError, channel};
-use crate::sync::{Arc, Barrier};
-use crate::thread;
+use std::sync::mpsc::{TryRecvError, channel};
+use std::sync::{Arc, Barrier};
+use std::thread;
 
 #[test]
 #[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
diff --git a/library/std/src/sync/poison/condvar/tests.rs b/library/std/tests/sync/condvar.rs
index f9e9066bc92..834de6bb1c2 100644
--- a/library/std/src/sync/poison/condvar/tests.rs
+++ b/library/std/tests/sync/condvar.rs
@@ -1,8 +1,8 @@
-use crate::sync::atomic::{AtomicBool, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{Arc, Condvar, Mutex};
-use crate::thread;
-use crate::time::Duration;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread;
+use std::time::Duration;
 
 #[test]
 fn smoke() {
diff --git a/library/std/src/sync/lazy_lock/tests.rs b/library/std/tests/sync/lazy_lock.rs
index 7d7dde54349..6c14b79f2ce 100644
--- a/library/std/src/sync/lazy_lock/tests.rs
+++ b/library/std/tests/sync/lazy_lock.rs
@@ -1,8 +1,8 @@
-use crate::cell::LazyCell;
-use crate::sync::atomic::AtomicUsize;
-use crate::sync::atomic::Ordering::SeqCst;
-use crate::sync::{LazyLock, Mutex, OnceLock};
-use crate::{panic, thread};
+use std::cell::LazyCell;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
+use std::sync::{LazyLock, Mutex, OnceLock};
+use std::{panic, thread};
 
 fn spawn_and_wait<R: Send + 'static>(f: impl FnOnce() -> R + Send + 'static) -> R {
     thread::spawn(f).join().unwrap()
@@ -149,7 +149,7 @@ fn is_sync_send() {
 #[should_panic = "has previously been poisoned"]
 fn lazy_force_mut_panic() {
     let mut lazy = LazyLock::<String>::new(|| panic!());
-    crate::panic::catch_unwind(crate::panic::AssertUnwindSafe(|| {
+    panic::catch_unwind(panic::AssertUnwindSafe(|| {
         let _ = LazyLock::force_mut(&mut lazy);
     }))
     .unwrap_err();
diff --git a/library/std/tests/sync/lib.rs b/library/std/tests/sync/lib.rs
new file mode 100644
index 00000000000..6bf320d52f2
--- /dev/null
+++ b/library/std/tests/sync/lib.rs
@@ -0,0 +1,32 @@
+#![feature(lazy_get)]
+#![feature(mapped_lock_guards)]
+#![feature(mpmc_channel)]
+#![feature(once_cell_try)]
+#![feature(once_wait)]
+#![feature(lock_value_accessors)]
+#![feature(reentrant_lock)]
+#![feature(rwlock_downgrade)]
+#![feature(std_internals)]
+#![allow(internal_features)]
+
+mod barrier;
+mod condvar;
+mod lazy_lock;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod mpmc;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod mpsc;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod mpsc_sync;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod mutex;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod once;
+mod once_lock;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod reentrant_lock;
+#[cfg(not(any(target_os = "emscripten", target_os = "wasi")))]
+mod rwlock;
+
+#[path = "../common/mod.rs"]
+mod common;
diff --git a/library/std/src/sync/mpmc/tests.rs b/library/std/tests/sync/mpmc.rs
index ab14050df6c..81b92297f76 100644
--- a/library/std/src/sync/mpmc/tests.rs
+++ b/library/std/tests/sync/mpmc.rs
@@ -1,5 +1,6 @@
-use super::*;
-use crate::{env, thread};
+use std::sync::mpmc::*;
+use std::time::{Duration, Instant};
+use std::{env, thread};
 
 pub fn stress_factor() -> usize {
     match env::var("RUST_TEST_STRESS") {
diff --git a/library/std/src/sync/mpsc/tests.rs b/library/std/tests/sync/mpsc.rs
index 13892fa0d18..1d8edfde44b 100644
--- a/library/std/src/sync/mpsc/tests.rs
+++ b/library/std/tests/sync/mpsc.rs
@@ -1,5 +1,6 @@
-use super::*;
-use crate::{env, thread};
+use std::sync::mpsc::*;
+use std::time::{Duration, Instant};
+use std::{env, thread};
 
 pub fn stress_factor() -> usize {
     match env::var("RUST_TEST_STRESS") {
diff --git a/library/std/src/sync/mpsc/sync_tests.rs b/library/std/tests/sync/mpsc_sync.rs
index 49b65c8efe6..a7f326d201b 100644
--- a/library/std/src/sync/mpsc/sync_tests.rs
+++ b/library/std/tests/sync/mpsc_sync.rs
@@ -1,7 +1,8 @@
-use super::*;
-use crate::rc::Rc;
-use crate::sync::mpmc::SendTimeoutError;
-use crate::{env, thread};
+use std::rc::Rc;
+use std::sync::mpmc::SendTimeoutError;
+use std::sync::mpsc::*;
+use std::time::Duration;
+use std::{env, thread};
 
 pub fn stress_factor() -> usize {
     match env::var("RUST_TEST_STRESS") {
diff --git a/library/std/src/sync/poison/mutex/tests.rs b/library/std/tests/sync/mutex.rs
index 395c8aada08..74c62720107 100644
--- a/library/std/src/sync/poison/mutex/tests.rs
+++ b/library/std/tests/sync/mutex.rs
@@ -1,10 +1,10 @@
-use crate::fmt::Debug;
-use crate::ops::FnMut;
-use crate::panic::{self, AssertUnwindSafe};
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{Arc, Condvar, MappedMutexGuard, Mutex, MutexGuard, TryLockError};
-use crate::{hint, mem, thread};
+use std::fmt::Debug;
+use std::ops::FnMut;
+use std::panic::{self, AssertUnwindSafe};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::{Arc, Condvar, MappedMutexGuard, Mutex, MutexGuard, TryLockError};
+use std::{hint, mem, thread};
 
 struct Packet<T>(Arc<(Mutex<T>, Condvar)>);
 
diff --git a/library/std/src/sync/poison/once/tests.rs b/library/std/tests/sync/once.rs
index ce96468aeb6..a3ffc73fe06 100644
--- a/library/std/src/sync/poison/once/tests.rs
+++ b/library/std/tests/sync/once.rs
@@ -1,9 +1,9 @@
-use super::Once;
-use crate::sync::atomic::AtomicBool;
-use crate::sync::atomic::Ordering::Relaxed;
-use crate::sync::mpsc::channel;
-use crate::time::Duration;
-use crate::{panic, thread};
+use std::sync::Once;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::Relaxed;
+use std::sync::mpsc::channel;
+use std::time::Duration;
+use std::{panic, thread};
 
 #[test]
 fn smoke_once() {
diff --git a/library/std/src/sync/once_lock/tests.rs b/library/std/tests/sync/once_lock.rs
index 5113d436c3c..1ce273b5a7a 100644
--- a/library/std/src/sync/once_lock/tests.rs
+++ b/library/std/tests/sync/once_lock.rs
@@ -1,8 +1,8 @@
-use crate::sync::OnceLock;
-use crate::sync::atomic::AtomicUsize;
-use crate::sync::atomic::Ordering::SeqCst;
-use crate::sync::mpsc::channel;
-use crate::{panic, thread};
+use std::sync::OnceLock;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
+use std::sync::mpsc::channel;
+use std::{panic, thread};
 
 fn spawn_and_wait<R: Send + 'static>(f: impl FnOnce() -> R + Send + 'static) -> R {
     thread::spawn(f).join().unwrap()
@@ -34,15 +34,6 @@ fn sync_once_cell_get_mut() {
 }
 
 #[test]
-fn sync_once_cell_get_unchecked() {
-    let c = OnceLock::new();
-    c.set(92).unwrap();
-    unsafe {
-        assert_eq!(c.get_unchecked(), &92);
-    }
-}
-
-#[test]
 #[cfg_attr(any(target_os = "emscripten", target_os = "wasi"), ignore)] // no threads
 fn sync_once_cell_drop() {
     static DROP_CNT: AtomicUsize = AtomicUsize::new(0);
@@ -88,7 +79,6 @@ fn get_or_try_init() {
 
     let res = panic::catch_unwind(|| cell.get_or_try_init(|| -> Result<_, ()> { panic!() }));
     assert!(res.is_err());
-    assert!(!cell.is_initialized());
     assert!(cell.get().is_none());
 
     assert_eq!(cell.get_or_try_init(|| Err(())), Err(()));
diff --git a/library/std/src/sync/reentrant_lock/tests.rs b/library/std/tests/sync/reentrant_lock.rs
index aeef0289d28..2b7b87e3623 100644
--- a/library/std/src/sync/reentrant_lock/tests.rs
+++ b/library/std/tests/sync/reentrant_lock.rs
@@ -1,7 +1,6 @@
-use super::ReentrantLock;
-use crate::cell::RefCell;
-use crate::sync::Arc;
-use crate::thread;
+use std::cell::RefCell;
+use std::sync::{Arc, ReentrantLock};
+use std::thread;
 
 #[test]
 fn smoke() {
diff --git a/library/std/src/sync/poison/rwlock/tests.rs b/library/std/tests/sync/rwlock.rs
index 057c2f1a5d7..bd4bc7a14bc 100644
--- a/library/std/src/sync/poison/rwlock/tests.rs
+++ b/library/std/tests/sync/rwlock.rs
@@ -1,15 +1,15 @@
-use rand::Rng;
-
-use crate::fmt::Debug;
-use crate::ops::FnMut;
-use crate::panic::{self, AssertUnwindSafe};
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::sync::mpsc::channel;
-use crate::sync::{
+use std::fmt::Debug;
+use std::ops::FnMut;
+use std::panic::{self, AssertUnwindSafe};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::channel;
+use std::sync::{
     Arc, MappedRwLockReadGuard, MappedRwLockWriteGuard, RwLock, RwLockReadGuard, RwLockWriteGuard,
     TryLockError,
 };
-use crate::{hint, mem, thread};
+use std::{hint, mem, thread};
+
+use rand::Rng;
 
 #[derive(Eq, PartialEq, Debug)]
 struct NonCopy(i32);
@@ -57,7 +57,7 @@ fn frob() {
         let tx = tx.clone();
         let r = r.clone();
         thread::spawn(move || {
-            let mut rng = crate::test_helpers::test_rng();
+            let mut rng = crate::common::test_rng();
             for _ in 0..M {
                 if rng.gen_bool(1.0 / (N as f64)) {
                     drop(r.write().unwrap());
@@ -704,7 +704,7 @@ fn test_downgrade_atomic() {
 
     // Wait for a good amount of time so that evil threads go to sleep.
     // Note: this is not strictly necessary...
-    let eternity = crate::time::Duration::from_millis(42);
+    let eternity = std::time::Duration::from_millis(42);
     thread::sleep(eternity);
 
     // Once everyone is asleep, set the value to `NEW_VALUE`.