library/std/src/io/tests.rs

   1 use super::{repeat, 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::ops::Deref;
   6
   7 #[test]
   8 #[cfg_attr(target_os = "emscripten", ignore)]
   9 fn read_until() {
  10     let mut buf = Cursor::new(&b"12"[..]);
  11     let mut v = Vec::new();
  12     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
  13     assert_eq!(v, b"12");
  14
  15     let mut buf = Cursor::new(&b"1233"[..]);
  16     let mut v = Vec::new();
  17     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
  18     assert_eq!(v, b"123");
  19     v.truncate(0);
  20     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);
  21     assert_eq!(v, b"3");
  22     v.truncate(0);
  23     assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);
  24     assert_eq!(v, []);
  25 }
  26
  27 #[test]
  28 fn split() {
  29     let buf = Cursor::new(&b"12"[..]);
  30     let mut s = buf.split(b'3');
  31     assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
  32     assert!(s.next().is_none());
  33
  34     let buf = Cursor::new(&b"1233"[..]);
  35     let mut s = buf.split(b'3');
  36     assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
  37     assert_eq!(s.next().unwrap().unwrap(), vec![]);
  38     assert!(s.next().is_none());
  39 }
  40
  41 #[test]
  42 fn read_line() {
  43     let mut buf = Cursor::new(&b"12"[..]);
  44     let mut v = String::new();
  45     assert_eq!(buf.read_line(&mut v).unwrap(), 2);
  46     assert_eq!(v, "12");
  47
  48     let mut buf = Cursor::new(&b"12\n\n"[..]);
  49     let mut v = String::new();
  50     assert_eq!(buf.read_line(&mut v).unwrap(), 3);
  51     assert_eq!(v, "12\n");
  52     v.truncate(0);
  53     assert_eq!(buf.read_line(&mut v).unwrap(), 1);
  54     assert_eq!(v, "\n");
  55     v.truncate(0);
  56     assert_eq!(buf.read_line(&mut v).unwrap(), 0);
  57     assert_eq!(v, "");
  58 }
  59
  60 #[test]
  61 fn lines() {
  62     let buf = Cursor::new(&b"12\r"[..]);
  63     let mut s = buf.lines();
  64     assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string());
  65     assert!(s.next().is_none());
  66
  67     let buf = Cursor::new(&b"12\r\n\n"[..]);
  68     let mut s = buf.lines();
  69     assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
  70     assert_eq!(s.next().unwrap().unwrap(), "".to_string());
  71     assert!(s.next().is_none());
  72 }
  73
  74 #[test]
  75 fn read_to_end() {
  76     let mut c = Cursor::new(&b""[..]);
  77     let mut v = Vec::new();
  78     assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
  79     assert_eq!(v, []);
  80
  81     let mut c = Cursor::new(&b"1"[..]);
  82     let mut v = Vec::new();
  83     assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
  84     assert_eq!(v, b"1");
  85
  86     let cap = 1024 * 1024;
  87     let data = (0..cap).map(|i| (i / 3) as u8).collect::<Vec<_>>();
  88     let mut v = Vec::new();
  89     let (a, b) = data.split_at(data.len() / 2);
  90     assert_eq!(Cursor::new(a).read_to_end(&mut v).unwrap(), a.len());
  91     assert_eq!(Cursor::new(b).read_to_end(&mut v).unwrap(), b.len());
  92     assert_eq!(v, data);
  93 }
  94
  95 #[test]
  96 fn read_to_string() {
  97     let mut c = Cursor::new(&b""[..]);
  98     let mut v = String::new();
  99     assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
 100     assert_eq!(v, "");
 101
 102     let mut c = Cursor::new(&b"1"[..]);
 103     let mut v = String::new();
 104     assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
 105     assert_eq!(v, "1");
 106
 107     let mut c = Cursor::new(&b"\xff"[..]);
 108     let mut v = String::new();
 109     assert!(c.read_to_string(&mut v).is_err());
 110 }
 111
 112 #[test]
 113 fn read_exact() {
 114     let mut buf = [0; 4];
 115
 116     let mut c = Cursor::new(&b""[..]);
 117     assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
 118
 119     let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
 120     c.read_exact(&mut buf).unwrap();
 121     assert_eq!(&buf, b"1234");
 122     c.read_exact(&mut buf).unwrap();
 123     assert_eq!(&buf, b"5678");
 124     assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
 125 }
 126
 127 #[test]
 128 fn read_exact_slice() {
 129     let mut buf = [0; 4];
 130
 131     let mut c = &b""[..];
 132     assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
 133
 134     let mut c = &b"123"[..];
 135     assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
 136     // make sure the optimized (early returning) method is being used
 137     assert_eq!(&buf, &[0; 4]);
 138
 139     let mut c = &b"1234"[..];
 140     c.read_exact(&mut buf).unwrap();
 141     assert_eq!(&buf, b"1234");
 142
 143     let mut c = &b"56789"[..];
 144     c.read_exact(&mut buf).unwrap();
 145     assert_eq!(&buf, b"5678");
 146     assert_eq!(c, b"9");
 147 }
 148
 149 #[test]
 150 fn take_eof() {
 151     struct R;
 152
 153     impl Read for R {
 154         fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
 155             Err(io::Error::new(io::ErrorKind::Other, ""))
 156         }
 157     }
 158     impl BufRead for R {
 159         fn fill_buf(&mut self) -> io::Result<&[u8]> {
 160             Err(io::Error::new(io::ErrorKind::Other, ""))
 161         }
 162         fn consume(&mut self, _amt: usize) {}
 163     }
 164
 165     let mut buf = [0; 1];
 166     assert_eq!(0, R.take(0).read(&mut buf).unwrap());
 167     assert_eq!(b"", R.take(0).fill_buf().unwrap());
 168 }
 169
 170 fn cmp_bufread<Br1: BufRead, Br2: BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {
 171     let mut cat = Vec::new();
 172     loop {
 173         let consume = {
 174             let buf1 = br1.fill_buf().unwrap();
 175             let buf2 = br2.fill_buf().unwrap();
 176             let minlen = if buf1.len() < buf2.len() { buf1.len() } else { buf2.len() };
 177             assert_eq!(buf1[..minlen], buf2[..minlen]);
 178             cat.extend_from_slice(&buf1[..minlen]);
 179             minlen
 180         };
 181         if consume == 0 {
 182             break;
 183         }
 184         br1.consume(consume);
 185         br2.consume(consume);
 186     }
 187     assert_eq!(br1.fill_buf().unwrap().len(), 0);
 188     assert_eq!(br2.fill_buf().unwrap().len(), 0);
 189     assert_eq!(&cat[..], &exp[..])
 190 }
 191
 192 #[test]
 193 fn chain_bufread() {
 194     let testdata = b"ABCDEFGHIJKL";
 195     let chain1 =
 196         (&testdata[..3]).chain(&testdata[3..6]).chain(&testdata[6..9]).chain(&testdata[9..]);
 197     let chain2 = (&testdata[..4]).chain(&testdata[4..8]).chain(&testdata[8..]);
 198     cmp_bufread(chain1, chain2, &testdata[..]);
 199 }
 200
 201 #[test]
 202 fn bufreader_size_hint() {
 203     let testdata = b"ABCDEFGHIJKL";
 204     let mut buf_reader = BufReader::new(&testdata[..]);
 205     assert_eq!(buf_reader.buffer().len(), 0);
 206
 207     let buffer_length = testdata.len();
 208     buf_reader.fill_buf().unwrap();
 209
 210     // Check that size hint matches buffer contents
 211     let mut buffered_bytes = buf_reader.bytes();
 212     let (lower_bound, _upper_bound) = buffered_bytes.size_hint();
 213     assert_eq!(lower_bound, buffer_length);
 214
 215     // Check that size hint matches buffer contents after advancing
 216     buffered_bytes.next().unwrap().unwrap();
 217     let (lower_bound, _upper_bound) = buffered_bytes.size_hint();
 218     assert_eq!(lower_bound, buffer_length - 1);
 219 }
 220
 221 #[test]
 222 fn empty_size_hint() {
 223     let size_hint = io::empty().bytes().size_hint();
 224     assert_eq!(size_hint, (0, Some(0)));
 225 }
 226
 227 #[test]
 228 fn chain_empty_size_hint() {
 229     let chain = io::empty().chain(io::empty());
 230     let size_hint = chain.bytes().size_hint();
 231     assert_eq!(size_hint, (0, Some(0)));
 232 }
 233
 234 #[test]
 235 fn chain_size_hint() {
 236     let testdata = b"ABCDEFGHIJKL";
 237     let mut buf_reader_1 = BufReader::new(&testdata[..6]);
 238     let mut buf_reader_2 = BufReader::new(&testdata[6..]);
 239
 240     buf_reader_1.fill_buf().unwrap();
 241     buf_reader_2.fill_buf().unwrap();
 242
 243     let chain = buf_reader_1.chain(buf_reader_2);
 244     let size_hint = chain.bytes().size_hint();
 245     assert_eq!(size_hint, (testdata.len(), None));
 246 }
 247
 248 #[test]
 249 fn chain_zero_length_read_is_not_eof() {
 250     let a = b"A";
 251     let b = b"B";
 252     let mut s = String::new();
 253     let mut chain = (&a[..]).chain(&b[..]);
 254     chain.read(&mut []).unwrap();
 255     chain.read_to_string(&mut s).unwrap();
 256     assert_eq!("AB", s);
 257 }
 258
 259 #[bench]
 260 #[cfg_attr(target_os = "emscripten", ignore)]
 261 fn bench_read_to_end(b: &mut test::Bencher) {
 262     b.iter(|| {
 263         let mut lr = repeat(1).take(10000000);
 264         let mut vec = Vec::with_capacity(1024);
 265         super::read_to_end(&mut lr, &mut vec)
 266     });
 267 }
 268
 269 #[test]
 270 fn seek_len() -> io::Result<()> {
 271     let mut c = Cursor::new(vec![0; 15]);
 272     assert_eq!(c.stream_len()?, 15);
 273
 274     c.seek(SeekFrom::End(0))?;
 275     let old_pos = c.stream_position()?;
 276     assert_eq!(c.stream_len()?, 15);
 277     assert_eq!(c.stream_position()?, old_pos);
 278
 279     c.seek(SeekFrom::Start(7))?;
 280     c.seek(SeekFrom::Current(2))?;
 281     let old_pos = c.stream_position()?;
 282     assert_eq!(c.stream_len()?, 15);
 283     assert_eq!(c.stream_position()?, old_pos);
 284
 285     Ok(())
 286 }
 287
 288 #[test]
 289 fn seek_position() -> io::Result<()> {
 290     // All `asserts` are duplicated here to make sure the method does not
 291     // change anything about the seek state.
 292     let mut c = Cursor::new(vec![0; 15]);
 293     assert_eq!(c.stream_position()?, 0);
 294     assert_eq!(c.stream_position()?, 0);
 295
 296     c.seek(SeekFrom::End(0))?;
 297     assert_eq!(c.stream_position()?, 15);
 298     assert_eq!(c.stream_position()?, 15);
 299
 300     c.seek(SeekFrom::Start(7))?;
 301     c.seek(SeekFrom::Current(2))?;
 302     assert_eq!(c.stream_position()?, 9);
 303     assert_eq!(c.stream_position()?, 9);
 304
 305     c.seek(SeekFrom::End(-3))?;
 306     c.seek(SeekFrom::Current(1))?;
 307     c.seek(SeekFrom::Current(-5))?;
 308     assert_eq!(c.stream_position()?, 8);
 309     assert_eq!(c.stream_position()?, 8);
 310
 311     Ok(())
 312 }
 313
 314 // A simple example reader which uses the default implementation of
 315 // read_to_end.
 316 struct ExampleSliceReader<'a> {
 317     slice: &'a [u8],
 318 }
 319
 320 impl<'a> Read for ExampleSliceReader<'a> {
 321     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 322         let len = cmp::min(self.slice.len(), buf.len());
 323         buf[..len].copy_from_slice(&self.slice[..len]);
 324         self.slice = &self.slice[len..];
 325         Ok(len)
 326     }
 327 }
 328
 329 #[test]
 330 fn test_read_to_end_capacity() -> io::Result<()> {
 331     let input = &b"foo"[..];
 332
 333     // read_to_end() generally needs to over-allocate, both for efficiency
 334     // and so that it can distinguish EOF. Assert that this is the case
 335     // with this simple ExampleSliceReader struct, which uses the default
 336     // implementation of read_to_end. Even though vec1 is allocated with
 337     // exactly enough capacity for the read, read_to_end will allocate more
 338     // space here.
 339     let mut vec1 = Vec::with_capacity(input.len());
 340     ExampleSliceReader { slice: input }.read_to_end(&mut vec1)?;
 341     assert_eq!(vec1.len(), input.len());
 342     assert!(vec1.capacity() > input.len(), "allocated more");
 343
 344     // However, std::io::Take includes an implementation of read_to_end
 345     // that will not allocate when the limit has already been reached. In
 346     // this case, vec2 never grows.
 347     let mut vec2 = Vec::with_capacity(input.len());
 348     ExampleSliceReader { slice: input }.take(input.len() as u64).read_to_end(&mut vec2)?;
 349     assert_eq!(vec2.len(), input.len());
 350     assert_eq!(vec2.capacity(), input.len(), "did not allocate more");
 351
 352     Ok(())
 353 }
 354
 355 #[test]
 356 fn io_slice_mut_advance() {
 357     let mut buf1 = [1; 8];
 358     let mut buf2 = [2; 16];
 359     let mut buf3 = [3; 8];
 360     let mut bufs = &mut [
 361         IoSliceMut::new(&mut buf1),
 362         IoSliceMut::new(&mut buf2),
 363         IoSliceMut::new(&mut buf3),
 364     ][..];
 365
 366     // Only in a single buffer..
 367     bufs = IoSliceMut::advance(bufs, 1);
 368     assert_eq!(bufs[0].deref(), [1; 7].as_ref());
 369     assert_eq!(bufs[1].deref(), [2; 16].as_ref());
 370     assert_eq!(bufs[2].deref(), [3; 8].as_ref());
 371
 372     // Removing a buffer, leaving others as is.
 373     bufs = IoSliceMut::advance(bufs, 7);
 374     assert_eq!(bufs[0].deref(), [2; 16].as_ref());
 375     assert_eq!(bufs[1].deref(), [3; 8].as_ref());
 376
 377     // Removing a buffer and removing from the next buffer.
 378     bufs = IoSliceMut::advance(bufs, 18);
 379     assert_eq!(bufs[0].deref(), [3; 6].as_ref());
 380 }
 381
 382 #[test]
 383 fn io_slice_mut_advance_empty_slice() {
 384     let empty_bufs = &mut [][..];
 385     // Shouldn't panic.
 386     IoSliceMut::advance(empty_bufs, 1);
 387 }
 388
 389 #[test]
 390 fn io_slice_mut_advance_beyond_total_length() {
 391     let mut buf1 = [1; 8];
 392     let mut bufs = &mut [IoSliceMut::new(&mut buf1)][..];
 393
 394     // Going beyond the total length should be ok.
 395     bufs = IoSliceMut::advance(bufs, 9);
 396     assert!(bufs.is_empty());
 397 }
 398
 399 #[test]
 400 fn io_slice_advance() {
 401     let buf1 = [1; 8];
 402     let buf2 = [2; 16];
 403     let buf3 = [3; 8];
 404     let mut bufs = &mut [IoSlice::new(&buf1), IoSlice::new(&buf2), IoSlice::new(&buf3)][..];
 405
 406     // Only in a single buffer..
 407     bufs = IoSlice::advance(bufs, 1);
 408     assert_eq!(bufs[0].deref(), [1; 7].as_ref());
 409     assert_eq!(bufs[1].deref(), [2; 16].as_ref());
 410     assert_eq!(bufs[2].deref(), [3; 8].as_ref());
 411
 412     // Removing a buffer, leaving others as is.
 413     bufs = IoSlice::advance(bufs, 7);
 414     assert_eq!(bufs[0].deref(), [2; 16].as_ref());
 415     assert_eq!(bufs[1].deref(), [3; 8].as_ref());
 416
 417     // Removing a buffer and removing from the next buffer.
 418     bufs = IoSlice::advance(bufs, 18);
 419     assert_eq!(bufs[0].deref(), [3; 6].as_ref());
 420 }
 421
 422 #[test]
 423 fn io_slice_advance_empty_slice() {
 424     let empty_bufs = &mut [][..];
 425     // Shouldn't panic.
 426     IoSlice::advance(empty_bufs, 1);
 427 }
 428
 429 #[test]
 430 fn io_slice_advance_beyond_total_length() {
 431     let buf1 = [1; 8];
 432     let mut bufs = &mut [IoSlice::new(&buf1)][..];
 433
 434     // Going beyond the total length should be ok.
 435     bufs = IoSlice::advance(bufs, 9);
 436     assert!(bufs.is_empty());
 437 }
 438
 439 /// Create a new writer that reads from at most `n_bufs` and reads
 440 /// `per_call` bytes (in total) per call to write.
 441 fn test_writer(n_bufs: usize, per_call: usize) -> TestWriter {
 442     TestWriter { n_bufs, per_call, written: Vec::new() }
 443 }
 444
 445 struct TestWriter {
 446     n_bufs: usize,
 447     per_call: usize,
 448     written: Vec<u8>,
 449 }
 450
 451 impl Write for TestWriter {
 452     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 453         self.write_vectored(&[IoSlice::new(buf)])
 454     }
 455
 456     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 457         let mut left = self.per_call;
 458         let mut written = 0;
 459         for buf in bufs.iter().take(self.n_bufs) {
 460             let n = min(left, buf.len());
 461             self.written.extend_from_slice(&buf[0..n]);
 462             left -= n;
 463             written += n;
 464         }
 465         Ok(written)
 466     }
 467
 468     fn flush(&mut self) -> io::Result<()> {
 469         Ok(())
 470     }
 471 }
 472
 473 #[test]
 474 fn test_writer_read_from_one_buf() {
 475     let mut writer = test_writer(1, 2);
 476
 477     assert_eq!(writer.write(&[]).unwrap(), 0);
 478     assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 479
 480     // Read at most 2 bytes.
 481     assert_eq!(writer.write(&[1, 1, 1]).unwrap(), 2);
 482     let bufs = &[IoSlice::new(&[2, 2, 2])];
 483     assert_eq!(writer.write_vectored(bufs).unwrap(), 2);
 484
 485     // Only read from first buf.
 486     let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4, 4])];
 487     assert_eq!(writer.write_vectored(bufs).unwrap(), 1);
 488
 489     assert_eq!(writer.written, &[1, 1, 2, 2, 3]);
 490 }
 491
 492 #[test]
 493 fn test_writer_read_from_multiple_bufs() {
 494     let mut writer = test_writer(3, 3);
 495
 496     // Read at most 3 bytes from two buffers.
 497     let bufs = &[IoSlice::new(&[1]), IoSlice::new(&[2, 2, 2])];
 498     assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
 499
 500     // Read at most 3 bytes from three buffers.
 501     let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4]), IoSlice::new(&[5, 5])];
 502     assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
 503
 504     assert_eq!(writer.written, &[1, 2, 2, 3, 4, 5]);
 505 }
 506
 507 #[test]
 508 fn test_write_all_vectored() {
 509     #[rustfmt::skip] // Becomes unreadable otherwise.
 510     let tests: Vec<(_, &'static [u8])> = vec![
 511         (vec![], &[]),
 512         (vec![IoSlice::new(&[]), IoSlice::new(&[])], &[]),
 513         (vec![IoSlice::new(&[1])], &[1]),
 514         (vec![IoSlice::new(&[1, 2])], &[1, 2]),
 515         (vec![IoSlice::new(&[1, 2, 3])], &[1, 2, 3]),
 516         (vec![IoSlice::new(&[1, 2, 3, 4])], &[1, 2, 3, 4]),
 517         (vec![IoSlice::new(&[1, 2, 3, 4, 5])], &[1, 2, 3, 4, 5]),
 518         (vec![IoSlice::new(&[1]), IoSlice::new(&[2])], &[1, 2]),
 519         (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2])], &[1, 2, 2]),
 520         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2])], &[1, 1, 2, 2]),
 521         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
 522         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
 523         (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 1, 2, 2, 2]),
 524         (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 2, 2, 2, 2]),
 525         (vec![IoSlice::new(&[1, 1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 1, 2, 2, 2, 2]),
 526         (vec![IoSlice::new(&[1]), IoSlice::new(&[2]), IoSlice::new(&[3])], &[1, 2, 3]),
 527         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3])], &[1, 1, 2, 2, 3, 3]),
 528         (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 2, 2, 3, 3, 3]),
 529         (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]),
 530     ];
 531
 532     let writer_configs = &[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)];
 533
 534     for (n_bufs, per_call) in writer_configs.iter().copied() {
 535         for (mut input, wanted) in tests.clone().into_iter() {
 536             let mut writer = test_writer(n_bufs, per_call);
 537             assert!(writer.write_all_vectored(&mut *input).is_ok());
 538             assert_eq!(&*writer.written, &*wanted);
 539         }
 540     }
 541 }