Skip to content

Commit 6e053fc

Browse files
thaliaarchithaliaarchi
committed
Implement default methods for io::Empty and io::Sink
1 parent d8810e3 commit 6e053fc

File tree

3 files changed

+216
-13
lines changed

3 files changed

+216
-13
lines changed

‎library/std/src/io/util.rs

+114
Original file line numberDiff line numberDiff line change
@@ -68,27 +68,81 @@ impl Read for Empty {
6868
fn read_buf(&mut self, _cursor: BorrowedCursor<'_>) -> io::Result<()> {
6969
Ok(())
7070
}
71+
72+
#[inline]
73+
fn read_vectored(&mut self, _bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
74+
Ok(0)
75+
}
76+
77+
#[inline]
78+
fn is_read_vectored(&self) -> bool {
79+
true
80+
}
81+
82+
#[inline]
83+
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
84+
if !buf.is_empty() { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
85+
}
86+
87+
#[inline]
88+
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
89+
if cursor.capacity() != 0 { Err(io::Error::READ_EXACT_EOF) } else { Ok(()) }
90+
}
91+
92+
#[inline]
93+
fn read_to_end(&mut self, _buf: &mut Vec<u8>) -> io::Result<usize> {
94+
Ok(0)
95+
}
96+
97+
#[inline]
98+
fn read_to_string(&mut self, _buf: &mut String) -> io::Result<usize> {
99+
Ok(0)
100+
}
71101
}
72102
#[stable(feature = "rust1", since = "1.0.0")]
73103
impl BufRead for Empty {
74104
#[inline]
75105
fn fill_buf(&mut self) -> io::Result<&[u8]> {
76106
Ok(&[])
77107
}
108+
78109
#[inline]
79110
fn consume(&mut self, _n: usize) {}
111+
112+
#[inline]
113+
fn has_data_left(&mut self) -> io::Result<bool> {
114+
Ok(false)
115+
}
116+
117+
#[inline]
118+
fn read_until(&mut self, _byte: u8, _buf: &mut Vec<u8>) -> io::Result<usize> {
119+
Ok(0)
120+
}
121+
122+
#[inline]
123+
fn skip_until(&mut self, _byte: u8) -> io::Result<usize> {
124+
Ok(0)
125+
}
126+
127+
#[inline]
128+
fn read_line(&mut self, _buf: &mut String) -> io::Result<usize> {
129+
Ok(0)
130+
}
80131
}
81132

82133
#[stable(feature = "empty_seek", since = "1.51.0")]
83134
impl Seek for Empty {
135+
#[inline]
84136
fn seek(&mut self, _pos: SeekFrom) -> io::Result<u64> {
85137
Ok(0)
86138
}
87139

140+
#[inline]
88141
fn stream_len(&mut self) -> io::Result<u64> {
89142
Ok(0)
90143
}
91144

145+
#[inline]
92146
fn stream_position(&mut self) -> io::Result<u64> {
93147
Ok(0)
94148
}
@@ -119,6 +173,21 @@ impl Write for Empty {
119173
true
120174
}
121175

176+
#[inline]
177+
fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
178+
Ok(())
179+
}
180+
181+
#[inline]
182+
fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
183+
Ok(())
184+
}
185+
186+
#[inline]
187+
fn write_fmt(&mut self, _fmt: fmt::Arguments<'_>) -> io::Result<()> {
188+
Ok(())
189+
}
190+
122191
#[inline]
123192
fn flush(&mut self) -> io::Result<()> {
124193
Ok(())
@@ -143,6 +212,21 @@ impl Write for &Empty {
143212
true
144213
}
145214

215+
#[inline]
216+
fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
217+
Ok(())
218+
}
219+
220+
#[inline]
221+
fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
222+
Ok(())
223+
}
224+
225+
#[inline]
226+
fn write_fmt(&mut self, _fmt: fmt::Arguments<'_>) -> io::Result<()> {
227+
Ok(())
228+
}
229+
146230
#[inline]
147231
fn flush(&mut self) -> io::Result<()> {
148232
Ok(())
@@ -302,6 +386,21 @@ impl Write for Sink {
302386
true
303387
}
304388

389+
#[inline]
390+
fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
391+
Ok(())
392+
}
393+
394+
#[inline]
395+
fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
396+
Ok(())
397+
}
398+
399+
#[inline]
400+
fn write_fmt(&mut self, _fmt: fmt::Arguments<'_>) -> io::Result<()> {
401+
Ok(())
402+
}
403+
305404
#[inline]
306405
fn flush(&mut self) -> io::Result<()> {
307406
Ok(())
@@ -326,6 +425,21 @@ impl Write for &Sink {
326425
true
327426
}
328427

428+
#[inline]
429+
fn write_all(&mut self, _buf: &[u8]) -> io::Result<()> {
430+
Ok(())
431+
}
432+
433+
#[inline]
434+
fn write_all_vectored(&mut self, _bufs: &mut [IoSlice<'_>]) -> io::Result<()> {
435+
Ok(())
436+
}
437+
438+
#[inline]
439+
fn write_fmt(&mut self, _fmt: fmt::Arguments<'_>) -> io::Result<()> {
440+
Ok(())
441+
}
442+
329443
#[inline]
330444
fn flush(&mut self) -> io::Result<()> {
331445
Ok(())

‎library/std/src/io/util/tests.rs

+100-11
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,51 @@
1+
use crate::fmt;
12
use crate::io::prelude::*;
2-
use crate::io::{BorrowedBuf, Empty, Repeat, SeekFrom, Sink, empty, repeat, sink};
3+
use crate::io::{
4+
BorrowedBuf, Empty, ErrorKind, IoSlice, IoSliceMut, Repeat, SeekFrom, Sink, empty, repeat, sink,
5+
};
36
use crate::mem::MaybeUninit;
47

8+
struct ErrorDisplay;
9+
10+
impl fmt::Display for ErrorDisplay {
11+
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
12+
Err(fmt::Error)
13+
}
14+
}
15+
16+
struct PanicDisplay;
17+
18+
impl fmt::Display for PanicDisplay {
19+
fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
20+
panic!()
21+
}
22+
}
23+
24+
#[track_caller]
25+
fn test_sinking<W: Write>(mut w: W) {
26+
assert_eq!(w.write(&[]).unwrap(), 0);
27+
assert_eq!(w.write(&[0]).unwrap(), 1);
28+
assert_eq!(w.write(&[0; 1024]).unwrap(), 1024);
29+
w.write_all(&[]).unwrap();
30+
w.write_all(&[0]).unwrap();
31+
w.write_all(&[0; 1024]).unwrap();
32+
let mut bufs =
33+
[IoSlice::new(&[]), IoSlice::new(&[0]), IoSlice::new(&[0; 1024]), IoSlice::new(&[])];
34+
assert!(w.is_write_vectored());
35+
assert_eq!(w.write_vectored(&[]).unwrap(), 0);
36+
assert_eq!(w.write_vectored(&bufs).unwrap(), 1025);
37+
w.write_all_vectored(&mut []).unwrap();
38+
w.write_all_vectored(&mut bufs).unwrap();
39+
assert!(w.flush().is_ok());
40+
assert_eq!(w.by_ref().write(&[0; 1024]).unwrap(), 1024);
41+
// Ignores fmt arguments
42+
w.write_fmt(format_args!("{}", ErrorDisplay)).unwrap();
43+
w.write_fmt(format_args!("{}", PanicDisplay)).unwrap();
44+
}
45+
546
#[test]
647
fn sink_sinks() {
7-
let mut s = sink();
8-
assert_eq!(s.write(&[]).unwrap(), 0);
9-
assert_eq!(s.write(&[0]).unwrap(), 1);
10-
assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
11-
assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
48+
test_sinking(sink());
1249
}
1350

1451
#[test]
@@ -19,6 +56,21 @@ fn empty_reads() {
1956
assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
2057
assert_eq!(Read::by_ref(&mut e).read(&mut [0; 1024]).unwrap(), 0);
2158

59+
e.read_exact(&mut []).unwrap();
60+
assert_eq!(e.read_exact(&mut [0]).unwrap_err().kind(), ErrorKind::UnexpectedEof);
61+
assert_eq!(e.read_exact(&mut [0; 1024]).unwrap_err().kind(), ErrorKind::UnexpectedEof);
62+
63+
assert!(e.is_read_vectored());
64+
assert_eq!(e.read_vectored(&mut []).unwrap(), 0);
65+
let (mut buf1, mut buf1024) = ([0], [0; 1024]);
66+
let bufs = &mut [
67+
IoSliceMut::new(&mut []),
68+
IoSliceMut::new(&mut buf1),
69+
IoSliceMut::new(&mut buf1024),
70+
IoSliceMut::new(&mut []),
71+
];
72+
assert_eq!(e.read_vectored(bufs).unwrap(), 0);
73+
2274
let buf: &mut [MaybeUninit<_>] = &mut [];
2375
let mut buf: BorrowedBuf<'_> = buf.into();
2476
e.read_buf(buf.unfilled()).unwrap();
@@ -42,6 +94,47 @@ fn empty_reads() {
4294
Read::by_ref(&mut e).read_buf(buf.unfilled()).unwrap();
4395
assert_eq!(buf.len(), 0);
4496
assert_eq!(buf.init_len(), 0);
97+
98+
let buf: &mut [MaybeUninit<_>] = &mut [];
99+
let mut buf: BorrowedBuf<'_> = buf.into();
100+
e.read_buf_exact(buf.unfilled()).unwrap();
101+
assert_eq!(buf.len(), 0);
102+
assert_eq!(buf.init_len(), 0);
103+
104+
let buf: &mut [_] = &mut [MaybeUninit::uninit()];
105+
let mut buf: BorrowedBuf<'_> = buf.into();
106+
assert_eq!(e.read_buf_exact(buf.unfilled()).unwrap_err().kind(), ErrorKind::UnexpectedEof);
107+
assert_eq!(buf.len(), 0);
108+
assert_eq!(buf.init_len(), 0);
109+
110+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
111+
let mut buf: BorrowedBuf<'_> = buf.into();
112+
assert_eq!(e.read_buf_exact(buf.unfilled()).unwrap_err().kind(), ErrorKind::UnexpectedEof);
113+
assert_eq!(buf.len(), 0);
114+
assert_eq!(buf.init_len(), 0);
115+
116+
let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
117+
let mut buf: BorrowedBuf<'_> = buf.into();
118+
assert_eq!(
119+
Read::by_ref(&mut e).read_buf_exact(buf.unfilled()).unwrap_err().kind(),
120+
ErrorKind::UnexpectedEof,
121+
);
122+
assert_eq!(buf.len(), 0);
123+
assert_eq!(buf.init_len(), 0);
124+
125+
let mut buf = Vec::new();
126+
assert_eq!(e.read_to_end(&mut buf).unwrap(), 0);
127+
assert_eq!(buf, vec![]);
128+
let mut buf = vec![1, 2, 3];
129+
assert_eq!(e.read_to_end(&mut buf).unwrap(), 0);
130+
assert_eq!(buf, vec![1, 2, 3]);
131+
132+
let mut buf = String::new();
133+
assert_eq!(e.read_to_string(&mut buf).unwrap(), 0);
134+
assert_eq!(buf, "");
135+
let mut buf = "hello".to_owned();
136+
assert_eq!(e.read_to_string(&mut buf).unwrap(), 0);
137+
assert_eq!(buf, "hello");
45138
}
46139

47140
#[test]
@@ -66,11 +159,7 @@ fn empty_seeks() {
66159

67160
#[test]
68161
fn empty_sinks() {
69-
let mut e = empty();
70-
assert_eq!(e.write(&[]).unwrap(), 0);
71-
assert_eq!(e.write(&[0]).unwrap(), 1);
72-
assert_eq!(e.write(&[0; 1024]).unwrap(), 1024);
73-
assert_eq!(Write::by_ref(&mut e).write(&[0; 1024]).unwrap(), 1024);
162+
test_sinking(empty());
74163
}
75164

76165
#[test]

‎tests/ui/write-fmt-errors.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@
44
#![feature(io_error_uncategorized)]
55

66
use std::fmt;
7-
use std::io::{self, Error, Write, sink};
7+
use std::io::{self, Error, Write};
88
use std::panic::catch_unwind;
99

1010
struct ErrorDisplay;
@@ -33,7 +33,7 @@ fn main() {
3333
assert!(res.is_err(), "writer error did not propagate");
3434

3535
// Test that the error from the formatter is detected.
36-
let res = catch_unwind(|| write!(sink(), "{} {} {}", 1, ErrorDisplay, "bar"));
36+
let res = catch_unwind(|| write!(vec![], "{} {} {}", 1, ErrorDisplay, "bar"));
3737
let err = res.expect_err("formatter error did not lead to panic").downcast::<&str>().unwrap();
3838
assert!(
3939
err.contains("formatting trait implementation returned an error"),

0 commit comments

Comments
 (0)