From 653520afb2fb75df7e7e88ab068202cd66725fa2 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Sat, 20 Sep 2025 11:39:07 +0200
Subject: [PATCH] std: update pipe tests

---
 .../std/src/sys/io/kernel_copy/linux/tests.rs | 14 ++--------
 library/std/src/sys/pal/windows/handle.rs     |  3 ---
 .../std/src/sys/pal/windows/handle/tests.rs   | 22 ---------------
 library/std/src/sys/process/windows/tests.rs  | 27 ++++++++++++++++++-
 4 files changed, 28 insertions(+), 38 deletions(-)
 delete mode 100644 library/std/src/sys/pal/windows/handle/tests.rs

diff --git a/library/std/src/sys/io/kernel_copy/linux/tests.rs b/library/std/src/sys/io/kernel_copy/linux/tests.rs
index 15dee768d928..9b2d9cbef990 100644
--- a/library/std/src/sys/io/kernel_copy/linux/tests.rs
+++ b/library/std/src/sys/io/kernel_copy/linux/tests.rs
@@ -88,13 +88,8 @@ fn dont_splice_pipes_from_files() -> Result<()> {
 
     use crate::io::SeekFrom;
     use crate::os::unix::fs::FileExt;
-    use crate::process::{ChildStdin, ChildStdout};
-    use crate::sys_common::FromInner;
 
-    let (read_end, write_end) = crate::sys::pipe::anon_pipe()?;
-
-    let mut read_end = ChildStdout::from_inner(read_end);
-    let mut write_end = ChildStdin::from_inner(write_end);
+    let (mut read_end, mut write_end) = crate::io::pipe()?;
 
     let tmp_path = tmpdir();
     let file = tmp_path.join("to_be_modified");
@@ -220,13 +215,8 @@ fn bench_file_to_uds_copy(b: &mut test::Bencher) {
 fn bench_socket_pipe_socket_copy(b: &mut test::Bencher) {
     use super::CopyResult;
     use crate::io::ErrorKind;
-    use crate::process::{ChildStdin, ChildStdout};
-    use crate::sys_common::FromInner;
 
-    let (read_end, write_end) = crate::sys::pipe::anon_pipe().unwrap();
-
-    let mut read_end = ChildStdout::from_inner(read_end);
-    let write_end = ChildStdin::from_inner(write_end);
+    let (mut read_end, write_end) = crate::io::pipe().unwrap();
 
     let acceptor = crate::net::TcpListener::bind("localhost:0").unwrap();
     let mut remote_end = crate::net::TcpStream::connect(acceptor.local_addr().unwrap()).unwrap();
diff --git a/library/std/src/sys/pal/windows/handle.rs b/library/std/src/sys/pal/windows/handle.rs
index 712f41ba8030..fc17e0b5ebd3 100644
--- a/library/std/src/sys/pal/windows/handle.rs
+++ b/library/std/src/sys/pal/windows/handle.rs
@@ -1,8 +1,5 @@
 #![unstable(issue = "none", feature = "windows_handle")]
 
-#[cfg(test)]
-mod tests;
-
 use core::ffi::c_void;
 use core::{cmp, mem, ptr};
 
diff --git a/library/std/src/sys/pal/windows/handle/tests.rs b/library/std/src/sys/pal/windows/handle/tests.rs
deleted file mode 100644
index 0c976ed84e6b..000000000000
--- a/library/std/src/sys/pal/windows/handle/tests.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use crate::sys::pipe::{Pipes, anon_pipe};
-use crate::{thread, time};
-
-/// Test the synchronous fallback for overlapped I/O.
-#[test]
-fn overlapped_handle_fallback() {
-    // Create some pipes. `ours` will be asynchronous.
-    let Pipes { ours, theirs } = anon_pipe(true, false).unwrap();
-
-    let async_readable = ours.into_handle();
-    let sync_writeable = theirs.into_handle();
-
-    thread::scope(|_| {
-        thread::sleep(time::Duration::from_millis(100));
-        sync_writeable.write(b"hello world!").unwrap();
-    });
-
-    // The pipe buffer starts empty so reading won't complete synchronously unless
-    // our fallback path works.
-    let mut buffer = [0u8; 1024];
-    async_readable.read(&mut buffer).unwrap();
-}
diff --git a/library/std/src/sys/process/windows/tests.rs b/library/std/src/sys/process/windows/tests.rs
index a21afe3363c5..bc5e0d5c7fc9 100644
--- a/library/std/src/sys/process/windows/tests.rs
+++ b/library/std/src/sys/process/windows/tests.rs
@@ -1,8 +1,10 @@
+use super::child_pipe::{Pipes, child_pipe};
 use super::{Arg, make_command_line};
-use crate::env;
 use crate::ffi::{OsStr, OsString};
 use crate::os::windows::io::AsHandle;
 use crate::process::{Command, Stdio};
+use crate::time::Duration;
+use crate::{env, thread};
 
 #[test]
 fn test_raw_args() {
@@ -233,3 +235,26 @@ fn windows_exe_resolver() {
         );
     }
 }
+
+/// Test the synchronous fallback for overlapped I/O.
+///
+/// While technically testing `Handle` functionality, this is situated in this
+/// module to allow easier access to `ChildPipe`.
+#[test]
+fn overlapped_handle_fallback() {
+    // Create some pipes. `ours` will be asynchronous.
+    let Pipes { ours, theirs } = child_pipe(true, false).unwrap();
+
+    let async_readable = ours.into_handle();
+    let sync_writeable = theirs.into_handle();
+
+    thread::scope(|_| {
+        thread::sleep(Duration::from_millis(100));
+        sync_writeable.write(b"hello world!").unwrap();
+    });
+
+    // The pipe buffer starts empty so reading won't complete synchronously unless
+    // our fallback path works.
+    let mut buffer = [0u8; 1024];
+    async_readable.read(&mut buffer).unwrap();
+}