WIP: Move std::io tests into alloctests

Author: bushrat011899

library/alloc/src/io/buffered/bufreader.rs

@@ -295,8 +295,9 @@ impl<R: ?Sized> BufReader<R> {
 }
 
 // This is only used by a test which asserts that the initialization-tracking is correct.
-#[cfg(test)]
 impl<R: ?Sized> BufReader<R> {
+    #[doc(hidden)]
+    #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
     #[allow(missing_docs)]
     pub fn initialized(&self) -> bool {
         self.buf.initialized()

library/alloc/src/io/buffered/bufreader/buffer.rs

@@ -79,7 +79,8 @@ impl Buffer {
     }
 
     // This is only used by a test which asserts that the initialization-tracking is correct.
-    #[cfg(test)]
+    #[doc(hidden)]
+    #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
     pub fn initialized(&self) -> bool {
         self.initialized
     }

library/alloc/src/io/buffered/bufwriter.rs

@@ -89,6 +89,7 @@ impl<W: Write> BufWriter<W> {
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
+    /// # #[expect(unused_mut)]
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -121,6 +122,7 @@ impl<W: Write> BufWriter<W> {
     /// use std::net::TcpStream;
     ///
     /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
+    /// # #[expect(unused_mut)]
     /// let mut buffer = BufWriter::with_capacity(100, stream);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -142,6 +144,7 @@ impl<W: Write> BufWriter<W> {
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
+    /// # #[expect(unused_mut)]
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // unwrap the TcpStream and flush the buffer
@@ -295,6 +298,7 @@ impl<W: ?Sized + Write> BufWriter<W> {
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
+    /// # #[expect(unused_mut)]
     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // we can use reference just like buffer

library/alloc/src/io/buffered/mod.rs

@@ -29,6 +29,7 @@ use crate::io::Error;
 /// use std::io::BufWriter;
 /// use std::net::TcpStream;
 ///
+/// # #[expect(unused_mut)]
 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 ///
 /// // do stuff with the stream
@@ -71,6 +72,7 @@ impl<W> IntoInnerError<W> {
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
+    /// # #[expect(unused_mut)]
     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // do stuff with the stream
@@ -105,6 +107,7 @@ impl<W> IntoInnerError<W> {
     /// use std::io::BufWriter;
     /// use std::net::TcpStream;
     ///
+    /// # #[expect(unused_mut)]
     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
     ///
     /// // do stuff with the stream

library/alloc/src/io/read.rs

@@ -248,6 +248,7 @@ pub trait Read {
     /// situations gracefully.
     ///
     /// ```no_run
+    /// # #![expect(dead_code)]
     /// # use std::io::{self, BufRead};
     /// # struct Example { example_datasource: io::Empty } impl Example {
     /// # fn get_some_data_for_the_example(&self) -> &'static [u8] { &[] }

library/std/src/io/buffered/tests.rs library/alloctests/tests/io/buffered.rslibrary/std/src/io/buffered/tests.rs renamed to library/alloctests/tests/io/buffered.rs

@@ -1,10 +1,14 @@
-use crate::io::prelude::*;
-use crate::io::{
-    self, BorrowedBuf, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, SeekFrom,
+//! Tests for buffering wrappers for I/O traits
+
+use alloc::io::{
+    self, BorrowedBuf, BufRead, BufReader, BufWriter, ErrorKind, IoSlice, LineWriter, Read, Seek,
+    SeekFrom, Write,
 };
-use crate::mem::MaybeUninit;
-use crate::sync::atomic::{AtomicUsize, Ordering};
-use crate::{panic, thread};
+use core::mem::MaybeUninit;
+use core::sync::atomic::{AtomicUsize, Ordering};
+use std::{panic, thread};
+
+extern crate test;
 
 /// A dummy reader intended at testing short-reads propagation.
 pub struct ShortReader {
@@ -681,7 +685,7 @@ fn line_vectored() {
 
 #[test]
 fn line_vectored_partial_and_errors() {
-    use crate::collections::VecDeque;
+    use alloc::collections::VecDeque;
 
     enum Call {
         Write { inputs: Vec<&'static [u8]>, output: io::Result<usize> },
@@ -1023,7 +1027,7 @@ struct WriteRecorder {
 
 impl Write for WriteRecorder {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        use crate::str::from_utf8;
+        use core::str::from_utf8;
 
         self.events.push(RecordedEvent::Write(from_utf8(buf).unwrap().to_string()));
         Ok(buf.len())
@@ -1056,7 +1060,7 @@ fn single_formatted_write() {
 fn bufreader_full_initialize() {
     struct OneByteReader;
     impl Read for OneByteReader {
-        fn read(&mut self, buf: &mut [u8]) -> crate::io::Result<usize> {
+        fn read(&mut self, buf: &mut [u8]) -> alloc::io::Result<usize> {
             if buf.len() > 0 {
                 buf[0] = 0;
                 Ok(1)
@@ -1079,7 +1083,7 @@ fn bufreader_full_initialize() {
 /// This is a regression test for https://github.com/rust-lang/rust/issues/127584.
 #[test]
 fn bufwriter_aliasing() {
-    use crate::io::{BufWriter, Cursor};
+    use alloc::io::{BufWriter, Cursor};
     let mut v = vec![0; 1024];
     let c = Cursor::new(&mut v);
     let w = BufWriter::new(Box::new(c));

library/std/src/io/cursor/tests.rs library/alloctests/tests/io/cursor.rslibrary/std/src/io/cursor/tests.rs renamed to library/alloctests/tests/io/cursor.rs

@@ -1,5 +1,6 @@
-use crate::io::prelude::*;
-use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
+use alloc::io::{Cursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
+
+extern crate test;
 
 #[test]
 fn test_vec_writer() {

library/std/src/io/tests.rs library/alloctests/tests/io/mod.rslibrary/std/src/io/tests.rs renamed to library/alloctests/tests/io/mod.rs

@@ -1,7 +1,15 @@
-use super::{BorrowedBuf, Cursor, SeekFrom, repeat};
-use crate::cmp::{self, min};
-use crate::io::{self, BufRead, BufReader, DEFAULT_BUF_SIZE, IoSlice, Read, Seek, Write};
-use crate::mem::MaybeUninit;
+mod buffered;
+mod cursor;
+mod util;
+
+use alloc::io::{
+    self, BorrowedBuf, BufRead, BufReader, Cursor, DEFAULT_BUF_SIZE, IoSlice, Read, Seek, SeekFrom,
+    Write, repeat,
+};
+use core::cmp::{self, min};
+use core::mem::MaybeUninit;
+
+extern crate test;
 
 #[test]
 fn read_until() {
@@ -270,7 +278,7 @@ fn chain_bufread() {
 #[test]
 fn chain_splitted_char() {
     let chain = b"\xc3".chain(b"\xa9".as_slice());
-    assert_eq!(crate::io::read_to_string(chain).unwrap(), "é");
+    assert_eq!(alloc::io::read_to_string(chain).unwrap(), "é");
 
     let mut chain = b"\xc3".chain(b"\xa9\n".as_slice());
     let mut buf = String::new();
@@ -360,7 +368,7 @@ fn bench_read_to_end(b: &mut test::Bencher) {
     b.iter(|| {
         let mut lr = repeat(1).take(10000000);
         let mut vec = Vec::with_capacity(1024);
-        super::default_read_to_end(&mut lr, &mut vec, None)
+        alloc::io::default_read_to_end(&mut lr, &mut vec, None)
     });
 }
 

library/std/src/io/util/tests.rs library/alloctests/tests/io/util.rslibrary/std/src/io/util/tests.rs renamed to library/alloctests/tests/io/util.rs

@@ -1,9 +1,9 @@
-use crate::fmt;
-use crate::io::prelude::*;
-use crate::io::{
-    BorrowedBuf, Empty, ErrorKind, IoSlice, IoSliceMut, Repeat, SeekFrom, Sink, empty, repeat, sink,
+use alloc::io::{
+    BorrowedBuf, Empty, ErrorKind, IoSlice, IoSliceMut, Read, Repeat, Seek, SeekFrom, Sink, Write,
+    empty, repeat, sink,
 };
-use crate::mem::MaybeUninit;
+use core::fmt;
+use core::mem::MaybeUninit;
 
 struct ErrorDisplay;
 

library/alloctests/tests/lib.rs

@@ -41,6 +41,18 @@
 #![feature(macro_metavar_expr_concat)]
 #![feature(vec_peek_mut)]
 #![feature(vec_try_remove)]
+#![feature(alloc_io)]
+#![feature(borrowed_buf_init)]
+#![feature(buf_read_has_data_left)]
+#![feature(can_vector)]
+#![feature(core_io_borrowed_buf)]
+#![feature(core_io_internals)]
+#![feature(cursor_split)]
+#![feature(io_const_error)]
+#![feature(read_buf)]
+#![feature(seek_io_take_position)]
+#![feature(seek_stream_len)]
+#![feature(write_all_vectored)]
 #![allow(internal_features)]
 #![deny(fuzzy_provenance_casts)]
 #![deny(unsafe_op_in_unsafe_fn)]
@@ -62,6 +74,7 @@ mod const_fns;
 mod cow_str;
 mod fmt;
 mod heap;
+mod io;
 mod linked_list;
 mod misc_tests;
 mod num;