1 use super::{repeat, BorrowedBuf, Cursor, SeekFrom};
2 use crate::cmp::{self, min};
3 use crate::io::{self, IoSlice, IoSliceMut};
4 use crate::io::{BufRead, BufReader, Read, Seek, Write};
5 use crate::mem::MaybeUninit;
9 #[cfg_attr(target_os = "emscripten", ignore)]
11 let mut buf = Cursor::new(&b"12"[..]);
12 let mut v = Vec::new();
13 assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
16 let mut buf = Cursor::new(&b"1233"[..]);
17 let mut v = Vec::new();
18 assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
19 assert_eq!(v, b"123");
21 assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
24 assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
30 let buf = Cursor::new(&b"12"[..]);
31 let mut s = buf.split(b'3');
32 assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
33 assert!(s.next().is_none());
35 let buf = Cursor::new(&b"1233"[..]);
36 let mut s = buf.split(b'3');
37 assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
38 assert_eq!(s.next().unwrap().unwrap(), vec![]);
39 assert!(s.next().is_none());
44 let mut buf = Cursor::new(&b"12"[..]);
45 let mut v = String::new();
46 assert_eq!(buf.read_line(&mut v).unwrap(), 2);
49 let mut buf = Cursor::new(&b"12\n\n"[..]);
50 let mut v = String::new();
51 assert_eq!(buf.read_line(&mut v).unwrap(), 3);
52 assert_eq!(v, "12\n");
54 assert_eq!(buf.read_line(&mut v).unwrap(), 1);
57 assert_eq!(buf.read_line(&mut v).unwrap(), 0);
63 let buf = Cursor::new(&b"12\r"[..]);
64 let mut s = buf.lines();
65 assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string());
66 assert!(s.next().is_none());
68 let buf = Cursor::new(&b"12\r\n\n"[..]);
69 let mut s = buf.lines();
70 assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
71 assert_eq!(s.next().unwrap().unwrap(), "".to_string());
72 assert!(s.next().is_none());
76 fn buf_read_has_data_left() {
77 let mut buf = Cursor::new(&b"abcd"[..]);
78 assert!(buf.has_data_left().unwrap());
79 buf.read_exact(&mut [0; 2]).unwrap();
80 assert!(buf.has_data_left().unwrap());
81 buf.read_exact(&mut [0; 2]).unwrap();
82 assert!(!buf.has_data_left().unwrap());
87 let mut c = Cursor::new(&b""[..]);
88 let mut v = Vec::new();
89 assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
92 let mut c = Cursor::new(&b"1"[..]);
93 let mut v = Vec::new();
94 assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
97 let cap = if cfg!(miri) { 1024 } else { 1024 * 1024 };
98 let data = (0..cap).map(|i| (i / 3) as u8).collect::<Vec<_>>();
99 let mut v = Vec::new();
100 let (a, b) = data.split_at(data.len() / 2);
101 assert_eq!(Cursor::new(a).read_to_end(&mut v).unwrap(), a.len());
102 assert_eq!(Cursor::new(b).read_to_end(&mut v).unwrap(), b.len());
107 fn read_to_string() {
108 let mut c = Cursor::new(&b""[..]);
109 let mut v = String::new();
110 assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
113 let mut c = Cursor::new(&b"1"[..]);
114 let mut v = String::new();
115 assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
118 let mut c = Cursor::new(&b"\xff"[..]);
119 let mut v = String::new();
120 assert!(c.read_to_string(&mut v).is_err());
125 let mut buf = [0; 4];
127 let mut c = Cursor::new(&b""[..]);
128 assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
130 let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
131 c.read_exact(&mut buf).unwrap();
132 assert_eq!(&buf, b"1234");
133 c.read_exact(&mut buf).unwrap();
134 assert_eq!(&buf, b"5678");
135 assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
139 fn read_exact_slice() {
140 let mut buf = [0; 4];
142 let mut c = &b""[..];
143 assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
145 let mut c = &b"123"[..];
146 assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
147 // make sure the optimized (early returning) method is being used
148 assert_eq!(&buf, &[0; 4]);
150 let mut c = &b"1234"[..];
151 c.read_exact(&mut buf).unwrap();
152 assert_eq!(&buf, b"1234");
154 let mut c = &b"56789"[..];
155 c.read_exact(&mut buf).unwrap();
156 assert_eq!(&buf, b"5678");
161 fn read_buf_exact() {
162 let buf: &mut [_] = &mut [0; 4];
163 let mut buf: BorrowedBuf<'_> = buf.into();
165 let mut c = Cursor::new(&b""[..]);
166 assert_eq!(c.read_buf_exact(buf.unfilled()).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
168 let mut c = Cursor::new(&b"123456789"[..]);
169 c.read_buf_exact(buf.unfilled()).unwrap();
170 assert_eq!(buf.filled(), b"1234");
174 c.read_buf_exact(buf.unfilled()).unwrap();
175 assert_eq!(buf.filled(), b"5678");
179 assert_eq!(c.read_buf_exact(buf.unfilled()).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
187 fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
188 Err(io::const_io_error!(io::ErrorKind::Other, ""))
192 fn fill_buf(&mut self) -> io::Result<&[u8]> {
193 Err(io::const_io_error!(io::ErrorKind::Other, ""))
195 fn consume(&mut self, _amt: usize) {}
198 let mut buf = [0; 1];
199 assert_eq!(0, R.take(0).read(&mut buf).unwrap());
200 assert_eq!(b"", R.take(0).fill_buf().unwrap());
203 fn cmp_bufread<Br1: BufRead, Br2: BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {
204 let mut cat = Vec::new();
207 let buf1 = br1.fill_buf().unwrap();
208 let buf2 = br2.fill_buf().unwrap();
209 let minlen = if buf1.len() < buf2.len() { buf1.len() } else { buf2.len() };
210 assert_eq!(buf1[..minlen], buf2[..minlen]);
211 cat.extend_from_slice(&buf1[..minlen]);
217 br1.consume(consume);
218 br2.consume(consume);
220 assert_eq!(br1.fill_buf().unwrap().len(), 0);
221 assert_eq!(br2.fill_buf().unwrap().len(), 0);
222 assert_eq!(&cat[..], &exp[..])
227 let testdata = b"ABCDEFGHIJKL";
229 (&testdata[..3]).chain(&testdata[3..6]).chain(&testdata[6..9]).chain(&testdata[9..]);
230 let chain2 = (&testdata[..4]).chain(&testdata[4..8]).chain(&testdata[8..]);
231 cmp_bufread(chain1, chain2, &testdata[..]);
235 fn bufreader_size_hint() {
236 let testdata = b"ABCDEFGHIJKL";
237 let mut buf_reader = BufReader::new(&testdata[..]);
238 assert_eq!(buf_reader.buffer().len(), 0);
240 let buffer_length = testdata.len();
241 buf_reader.fill_buf().unwrap();
243 // Check that size hint matches buffer contents
244 let mut buffered_bytes = buf_reader.bytes();
245 let (lower_bound, _upper_bound) = buffered_bytes.size_hint();
246 assert_eq!(lower_bound, buffer_length);
248 // Check that size hint matches buffer contents after advancing
249 buffered_bytes.next().unwrap().unwrap();
250 let (lower_bound, _upper_bound) = buffered_bytes.size_hint();
251 assert_eq!(lower_bound, buffer_length - 1);
255 fn empty_size_hint() {
256 let size_hint = io::empty().bytes().size_hint();
257 assert_eq!(size_hint, (0, Some(0)));
261 fn slice_size_hint() {
262 let size_hint = (&[1, 2, 3]).bytes().size_hint();
263 assert_eq!(size_hint, (3, Some(3)));
267 fn take_size_hint() {
268 let size_hint = (&[1, 2, 3]).take(2).bytes().size_hint();
269 assert_eq!(size_hint, (2, Some(2)));
271 let size_hint = (&[1, 2, 3]).take(4).bytes().size_hint();
272 assert_eq!(size_hint, (3, Some(3)));
274 let size_hint = io::repeat(0).take(3).bytes().size_hint();
275 assert_eq!(size_hint, (3, Some(3)));
279 fn chain_empty_size_hint() {
280 let chain = io::empty().chain(io::empty());
281 let size_hint = chain.bytes().size_hint();
282 assert_eq!(size_hint, (0, Some(0)));
286 fn chain_size_hint() {
287 let testdata = b"ABCDEFGHIJKL";
288 let mut buf_reader_1 = BufReader::new(&testdata[..6]);
289 let mut buf_reader_2 = BufReader::new(&testdata[6..]);
291 buf_reader_1.fill_buf().unwrap();
292 buf_reader_2.fill_buf().unwrap();
294 let chain = buf_reader_1.chain(buf_reader_2);
295 let size_hint = chain.bytes().size_hint();
296 assert_eq!(size_hint, (testdata.len(), Some(testdata.len())));
300 fn chain_zero_length_read_is_not_eof() {
303 let mut s = String::new();
304 let mut chain = (&a[..]).chain(&b[..]);
305 chain.read(&mut []).unwrap();
306 chain.read_to_string(&mut s).unwrap();
311 #[cfg_attr(target_os = "emscripten", ignore)]
312 #[cfg_attr(miri, ignore)] // Miri isn't fast...
313 fn bench_read_to_end(b: &mut test::Bencher) {
315 let mut lr = repeat(1).take(10000000);
316 let mut vec = Vec::with_capacity(1024);
317 super::default_read_to_end(&mut lr, &mut vec)
322 fn seek_len() -> io::Result<()> {
323 let mut c = Cursor::new(vec![0; 15]);
324 assert_eq!(c.stream_len()?, 15);
326 c.seek(SeekFrom::End(0))?;
327 let old_pos = c.stream_position()?;
328 assert_eq!(c.stream_len()?, 15);
329 assert_eq!(c.stream_position()?, old_pos);
331 c.seek(SeekFrom::Start(7))?;
332 c.seek(SeekFrom::Current(2))?;
333 let old_pos = c.stream_position()?;
334 assert_eq!(c.stream_len()?, 15);
335 assert_eq!(c.stream_position()?, old_pos);
341 fn seek_position() -> io::Result<()> {
342 // All `asserts` are duplicated here to make sure the method does not
343 // change anything about the seek state.
344 let mut c = Cursor::new(vec![0; 15]);
345 assert_eq!(c.stream_position()?, 0);
346 assert_eq!(c.stream_position()?, 0);
348 c.seek(SeekFrom::End(0))?;
349 assert_eq!(c.stream_position()?, 15);
350 assert_eq!(c.stream_position()?, 15);
352 c.seek(SeekFrom::Start(7))?;
353 c.seek(SeekFrom::Current(2))?;
354 assert_eq!(c.stream_position()?, 9);
355 assert_eq!(c.stream_position()?, 9);
357 c.seek(SeekFrom::End(-3))?;
358 c.seek(SeekFrom::Current(1))?;
359 c.seek(SeekFrom::Current(-5))?;
360 assert_eq!(c.stream_position()?, 8);
361 assert_eq!(c.stream_position()?, 8);
364 assert_eq!(c.stream_position()?, 0);
365 assert_eq!(c.stream_position()?, 0);
370 // A simple example reader which uses the default implementation of
372 struct ExampleSliceReader<'a> {
376 impl<'a> Read for ExampleSliceReader<'a> {
377 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
378 let len = cmp::min(self.slice.len(), buf.len());
379 buf[..len].copy_from_slice(&self.slice[..len]);
380 self.slice = &self.slice[len..];
386 fn test_read_to_end_capacity() -> io::Result<()> {
387 let input = &b"foo"[..];
389 // read_to_end() takes care not to over-allocate when a buffer is the
390 // exact size needed.
391 let mut vec1 = Vec::with_capacity(input.len());
392 ExampleSliceReader { slice: input }.read_to_end(&mut vec1)?;
393 assert_eq!(vec1.len(), input.len());
394 assert_eq!(vec1.capacity(), input.len(), "did not allocate more");
400 fn io_slice_mut_advance_slices() {
401 let mut buf1 = [1; 8];
402 let mut buf2 = [2; 16];
403 let mut buf3 = [3; 8];
404 let mut bufs = &mut [
405 IoSliceMut::new(&mut buf1),
406 IoSliceMut::new(&mut buf2),
407 IoSliceMut::new(&mut buf3),
410 // Only in a single buffer..
411 IoSliceMut::advance_slices(&mut bufs, 1);
412 assert_eq!(bufs[0].deref(), [1; 7].as_ref());
413 assert_eq!(bufs[1].deref(), [2; 16].as_ref());
414 assert_eq!(bufs[2].deref(), [3; 8].as_ref());
416 // Removing a buffer, leaving others as is.
417 IoSliceMut::advance_slices(&mut bufs, 7);
418 assert_eq!(bufs[0].deref(), [2; 16].as_ref());
419 assert_eq!(bufs[1].deref(), [3; 8].as_ref());
421 // Removing a buffer and removing from the next buffer.
422 IoSliceMut::advance_slices(&mut bufs, 18);
423 assert_eq!(bufs[0].deref(), [3; 6].as_ref());
428 fn io_slice_mut_advance_slices_empty_slice() {
429 let mut empty_bufs = &mut [][..];
430 IoSliceMut::advance_slices(&mut empty_bufs, 1);
435 fn io_slice_mut_advance_slices_beyond_total_length() {
436 let mut buf1 = [1; 8];
437 let mut bufs = &mut [IoSliceMut::new(&mut buf1)][..];
439 IoSliceMut::advance_slices(&mut bufs, 9);
440 assert!(bufs.is_empty());
444 fn io_slice_advance_slices() {
448 let mut bufs = &mut [IoSlice::new(&buf1), IoSlice::new(&buf2), IoSlice::new(&buf3)][..];
450 // Only in a single buffer..
451 IoSlice::advance_slices(&mut bufs, 1);
452 assert_eq!(bufs[0].deref(), [1; 7].as_ref());
453 assert_eq!(bufs[1].deref(), [2; 16].as_ref());
454 assert_eq!(bufs[2].deref(), [3; 8].as_ref());
456 // Removing a buffer, leaving others as is.
457 IoSlice::advance_slices(&mut bufs, 7);
458 assert_eq!(bufs[0].deref(), [2; 16].as_ref());
459 assert_eq!(bufs[1].deref(), [3; 8].as_ref());
461 // Removing a buffer and removing from the next buffer.
462 IoSlice::advance_slices(&mut bufs, 18);
463 assert_eq!(bufs[0].deref(), [3; 6].as_ref());
468 fn io_slice_advance_slices_empty_slice() {
469 let mut empty_bufs = &mut [][..];
470 IoSlice::advance_slices(&mut empty_bufs, 1);
475 fn io_slice_advance_slices_beyond_total_length() {
477 let mut bufs = &mut [IoSlice::new(&buf1)][..];
479 IoSlice::advance_slices(&mut bufs, 9);
480 assert!(bufs.is_empty());
483 /// Create a new writer that reads from at most `n_bufs` and reads
484 /// `per_call` bytes (in total) per call to write.
485 fn test_writer(n_bufs: usize, per_call: usize) -> TestWriter {
486 TestWriter { n_bufs, per_call, written: Vec::new() }
495 impl Write for TestWriter {
496 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
497 self.write_vectored(&[IoSlice::new(buf)])
500 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
501 let mut left = self.per_call;
503 for buf in bufs.iter().take(self.n_bufs) {
504 let n = min(left, buf.len());
505 self.written.extend_from_slice(&buf[0..n]);
512 fn flush(&mut self) -> io::Result<()> {
518 fn test_writer_read_from_one_buf() {
519 let mut writer = test_writer(1, 2);
521 assert_eq!(writer.write(&[]).unwrap(), 0);
522 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
524 // Read at most 2 bytes.
525 assert_eq!(writer.write(&[1, 1, 1]).unwrap(), 2);
526 let bufs = &[IoSlice::new(&[2, 2, 2])];
527 assert_eq!(writer.write_vectored(bufs).unwrap(), 2);
529 // Only read from first buf.
530 let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4, 4])];
531 assert_eq!(writer.write_vectored(bufs).unwrap(), 1);
533 assert_eq!(writer.written, &[1, 1, 2, 2, 3]);
537 fn test_writer_read_from_multiple_bufs() {
538 let mut writer = test_writer(3, 3);
540 // Read at most 3 bytes from two buffers.
541 let bufs = &[IoSlice::new(&[1]), IoSlice::new(&[2, 2, 2])];
542 assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
544 // Read at most 3 bytes from three buffers.
545 let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4]), IoSlice::new(&[5, 5])];
546 assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
548 assert_eq!(writer.written, &[1, 2, 2, 3, 4, 5]);
552 fn test_write_all_vectored() {
553 #[rustfmt::skip] // Becomes unreadable otherwise.
554 let tests: Vec<(_, &'static [u8])> = vec![
556 (vec![IoSlice::new(&[]), IoSlice::new(&[])], &[]),
557 (vec![IoSlice::new(&[1])], &[1]),
558 (vec![IoSlice::new(&[1, 2])], &[1, 2]),
559 (vec![IoSlice::new(&[1, 2, 3])], &[1, 2, 3]),
560 (vec![IoSlice::new(&[1, 2, 3, 4])], &[1, 2, 3, 4]),
561 (vec![IoSlice::new(&[1, 2, 3, 4, 5])], &[1, 2, 3, 4, 5]),
562 (vec![IoSlice::new(&[1]), IoSlice::new(&[2])], &[1, 2]),
563 (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2])], &[1, 2, 2]),
564 (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2])], &[1, 1, 2, 2]),
565 (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
566 (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
567 (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 1, 2, 2, 2]),
568 (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 2, 2, 2, 2]),
569 (vec![IoSlice::new(&[1, 1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 1, 2, 2, 2, 2]),
570 (vec![IoSlice::new(&[1]), IoSlice::new(&[2]), IoSlice::new(&[3])], &[1, 2, 3]),
571 (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3])], &[1, 1, 2, 2, 3, 3]),
572 (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 2, 2, 3, 3, 3]),
573 (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 1, 1, 2, 2, 2, 3, 3, 3]),
576 let writer_configs = &[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)];
578 for (n_bufs, per_call) in writer_configs.iter().copied() {
579 for (mut input, wanted) in tests.clone().into_iter() {
580 let mut writer = test_writer(n_bufs, per_call);
581 assert!(writer.write_all_vectored(&mut *input).is_ok());
582 assert_eq!(&*writer.written, &*wanted);
589 #[should_panic = "number of read bytes exceeds limit"]
590 fn test_take_wrong_length() {
591 struct LieAboutSize(bool);
593 impl Read for LieAboutSize {
594 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
595 // Lie about the read size at first time of read.
596 if core::mem::take(&mut self.0) { Ok(buf.len() + 1) } else { Ok(buf.len()) }
600 let mut buffer = vec![0; 4];
601 let mut reader = LieAboutSize(true).take(4);
602 // Primed the `Limit` by lying about the read size.
603 let _ = reader.read(&mut buffer[..]);
607 fn bench_take_read(b: &mut test::Bencher) {
609 let mut buf = [0; 64];
611 [255; 128].take(64).read(&mut buf).unwrap();
616 fn bench_take_read_buf(b: &mut test::Bencher) {
618 let buf: &mut [_] = &mut [MaybeUninit::uninit(); 64];
620 let mut buf: BorrowedBuf<'_> = buf.into();
622 [255; 128].take(64).read_buf(buf.unfilled()).unwrap();