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, 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 chain_zero_length_read_is_not_eof() {
 203     let a = b"A";
 204     let b = b"B";
 205     let mut s = String::new();
 206     let mut chain = (&a[..]).chain(&b[..]);
 207     chain.read(&mut []).unwrap();
 208     chain.read_to_string(&mut s).unwrap();
 209     assert_eq!("AB", s);
 210 }
 211
 212 #[bench]
 213 #[cfg_attr(target_os = "emscripten", ignore)]
 214 fn bench_read_to_end(b: &mut test::Bencher) {
 215     b.iter(|| {
 216         let mut lr = repeat(1).take(10000000);
 217         let mut vec = Vec::with_capacity(1024);
 218         super::read_to_end(&mut lr, &mut vec)
 219     });
 220 }
 221
 222 #[test]
 223 fn seek_len() -> io::Result<()> {
 224     let mut c = Cursor::new(vec![0; 15]);
 225     assert_eq!(c.stream_len()?, 15);
 226
 227     c.seek(SeekFrom::End(0))?;
 228     let old_pos = c.stream_position()?;
 229     assert_eq!(c.stream_len()?, 15);
 230     assert_eq!(c.stream_position()?, old_pos);
 231
 232     c.seek(SeekFrom::Start(7))?;
 233     c.seek(SeekFrom::Current(2))?;
 234     let old_pos = c.stream_position()?;
 235     assert_eq!(c.stream_len()?, 15);
 236     assert_eq!(c.stream_position()?, old_pos);
 237
 238     Ok(())
 239 }
 240
 241 #[test]
 242 fn seek_position() -> io::Result<()> {
 243     // All `asserts` are duplicated here to make sure the method does not
 244     // change anything about the seek state.
 245     let mut c = Cursor::new(vec![0; 15]);
 246     assert_eq!(c.stream_position()?, 0);
 247     assert_eq!(c.stream_position()?, 0);
 248
 249     c.seek(SeekFrom::End(0))?;
 250     assert_eq!(c.stream_position()?, 15);
 251     assert_eq!(c.stream_position()?, 15);
 252
 253     c.seek(SeekFrom::Start(7))?;
 254     c.seek(SeekFrom::Current(2))?;
 255     assert_eq!(c.stream_position()?, 9);
 256     assert_eq!(c.stream_position()?, 9);
 257
 258     c.seek(SeekFrom::End(-3))?;
 259     c.seek(SeekFrom::Current(1))?;
 260     c.seek(SeekFrom::Current(-5))?;
 261     assert_eq!(c.stream_position()?, 8);
 262     assert_eq!(c.stream_position()?, 8);
 263
 264     Ok(())
 265 }
 266
 267 // A simple example reader which uses the default implementation of
 268 // read_to_end.
 269 struct ExampleSliceReader<'a> {
 270     slice: &'a [u8],
 271 }
 272
 273 impl<'a> Read for ExampleSliceReader<'a> {
 274     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 275         let len = cmp::min(self.slice.len(), buf.len());
 276         buf[..len].copy_from_slice(&self.slice[..len]);
 277         self.slice = &self.slice[len..];
 278         Ok(len)
 279     }
 280 }
 281
 282 #[test]
 283 fn test_read_to_end_capacity() -> io::Result<()> {
 284     let input = &b"foo"[..];
 285
 286     // read_to_end() generally needs to over-allocate, both for efficiency
 287     // and so that it can distinguish EOF. Assert that this is the case
 288     // with this simple ExampleSliceReader struct, which uses the default
 289     // implementation of read_to_end. Even though vec1 is allocated with
 290     // exactly enough capacity for the read, read_to_end will allocate more
 291     // space here.
 292     let mut vec1 = Vec::with_capacity(input.len());
 293     ExampleSliceReader { slice: input }.read_to_end(&mut vec1)?;
 294     assert_eq!(vec1.len(), input.len());
 295     assert!(vec1.capacity() > input.len(), "allocated more");
 296
 297     // However, std::io::Take includes an implementation of read_to_end
 298     // that will not allocate when the limit has already been reached. In
 299     // this case, vec2 never grows.
 300     let mut vec2 = Vec::with_capacity(input.len());
 301     ExampleSliceReader { slice: input }.take(input.len() as u64).read_to_end(&mut vec2)?;
 302     assert_eq!(vec2.len(), input.len());
 303     assert_eq!(vec2.capacity(), input.len(), "did not allocate more");
 304
 305     Ok(())
 306 }
 307
 308 #[test]
 309 fn io_slice_mut_advance() {
 310     let mut buf1 = [1; 8];
 311     let mut buf2 = [2; 16];
 312     let mut buf3 = [3; 8];
 313     let mut bufs = &mut [
 314         IoSliceMut::new(&mut buf1),
 315         IoSliceMut::new(&mut buf2),
 316         IoSliceMut::new(&mut buf3),
 317     ][..];
 318
 319     // Only in a single buffer..
 320     bufs = IoSliceMut::advance(bufs, 1);
 321     assert_eq!(bufs[0].deref(), [1; 7].as_ref());
 322     assert_eq!(bufs[1].deref(), [2; 16].as_ref());
 323     assert_eq!(bufs[2].deref(), [3; 8].as_ref());
 324
 325     // Removing a buffer, leaving others as is.
 326     bufs = IoSliceMut::advance(bufs, 7);
 327     assert_eq!(bufs[0].deref(), [2; 16].as_ref());
 328     assert_eq!(bufs[1].deref(), [3; 8].as_ref());
 329
 330     // Removing a buffer and removing from the next buffer.
 331     bufs = IoSliceMut::advance(bufs, 18);
 332     assert_eq!(bufs[0].deref(), [3; 6].as_ref());
 333 }
 334
 335 #[test]
 336 fn io_slice_mut_advance_empty_slice() {
 337     let empty_bufs = &mut [][..];
 338     // Shouldn't panic.
 339     IoSliceMut::advance(empty_bufs, 1);
 340 }
 341
 342 #[test]
 343 fn io_slice_mut_advance_beyond_total_length() {
 344     let mut buf1 = [1; 8];
 345     let mut bufs = &mut [IoSliceMut::new(&mut buf1)][..];
 346
 347     // Going beyond the total length should be ok.
 348     bufs = IoSliceMut::advance(bufs, 9);
 349     assert!(bufs.is_empty());
 350 }
 351
 352 #[test]
 353 fn io_slice_advance() {
 354     let buf1 = [1; 8];
 355     let buf2 = [2; 16];
 356     let buf3 = [3; 8];
 357     let mut bufs = &mut [IoSlice::new(&buf1), IoSlice::new(&buf2), IoSlice::new(&buf3)][..];
 358
 359     // Only in a single buffer..
 360     bufs = IoSlice::advance(bufs, 1);
 361     assert_eq!(bufs[0].deref(), [1; 7].as_ref());
 362     assert_eq!(bufs[1].deref(), [2; 16].as_ref());
 363     assert_eq!(bufs[2].deref(), [3; 8].as_ref());
 364
 365     // Removing a buffer, leaving others as is.
 366     bufs = IoSlice::advance(bufs, 7);
 367     assert_eq!(bufs[0].deref(), [2; 16].as_ref());
 368     assert_eq!(bufs[1].deref(), [3; 8].as_ref());
 369
 370     // Removing a buffer and removing from the next buffer.
 371     bufs = IoSlice::advance(bufs, 18);
 372     assert_eq!(bufs[0].deref(), [3; 6].as_ref());
 373 }
 374
 375 #[test]
 376 fn io_slice_advance_empty_slice() {
 377     let empty_bufs = &mut [][..];
 378     // Shouldn't panic.
 379     IoSlice::advance(empty_bufs, 1);
 380 }
 381
 382 #[test]
 383 fn io_slice_advance_beyond_total_length() {
 384     let buf1 = [1; 8];
 385     let mut bufs = &mut [IoSlice::new(&buf1)][..];
 386
 387     // Going beyond the total length should be ok.
 388     bufs = IoSlice::advance(bufs, 9);
 389     assert!(bufs.is_empty());
 390 }
 391
 392 /// Create a new writer that reads from at most `n_bufs` and reads
 393 /// `per_call` bytes (in total) per call to write.
 394 fn test_writer(n_bufs: usize, per_call: usize) -> TestWriter {
 395     TestWriter { n_bufs, per_call, written: Vec::new() }
 396 }
 397
 398 struct TestWriter {
 399     n_bufs: usize,
 400     per_call: usize,
 401     written: Vec<u8>,
 402 }
 403
 404 impl Write for TestWriter {
 405     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 406         self.write_vectored(&[IoSlice::new(buf)])
 407     }
 408
 409     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 410         let mut left = self.per_call;
 411         let mut written = 0;
 412         for buf in bufs.iter().take(self.n_bufs) {
 413             let n = min(left, buf.len());
 414             self.written.extend_from_slice(&buf[0..n]);
 415             left -= n;
 416             written += n;
 417         }
 418         Ok(written)
 419     }
 420
 421     fn flush(&mut self) -> io::Result<()> {
 422         Ok(())
 423     }
 424 }
 425
 426 #[test]
 427 fn test_writer_read_from_one_buf() {
 428     let mut writer = test_writer(1, 2);
 429
 430     assert_eq!(writer.write(&[]).unwrap(), 0);
 431     assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 432
 433     // Read at most 2 bytes.
 434     assert_eq!(writer.write(&[1, 1, 1]).unwrap(), 2);
 435     let bufs = &[IoSlice::new(&[2, 2, 2])];
 436     assert_eq!(writer.write_vectored(bufs).unwrap(), 2);
 437
 438     // Only read from first buf.
 439     let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4, 4])];
 440     assert_eq!(writer.write_vectored(bufs).unwrap(), 1);
 441
 442     assert_eq!(writer.written, &[1, 1, 2, 2, 3]);
 443 }
 444
 445 #[test]
 446 fn test_writer_read_from_multiple_bufs() {
 447     let mut writer = test_writer(3, 3);
 448
 449     // Read at most 3 bytes from two buffers.
 450     let bufs = &[IoSlice::new(&[1]), IoSlice::new(&[2, 2, 2])];
 451     assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
 452
 453     // Read at most 3 bytes from three buffers.
 454     let bufs = &[IoSlice::new(&[3]), IoSlice::new(&[4]), IoSlice::new(&[5, 5])];
 455     assert_eq!(writer.write_vectored(bufs).unwrap(), 3);
 456
 457     assert_eq!(writer.written, &[1, 2, 2, 3, 4, 5]);
 458 }
 459
 460 #[test]
 461 fn test_write_all_vectored() {
 462     #[rustfmt::skip] // Becomes unreadable otherwise.
 463     let tests: Vec<(_, &'static [u8])> = vec![
 464         (vec![], &[]),
 465         (vec![IoSlice::new(&[]), IoSlice::new(&[])], &[]),
 466         (vec![IoSlice::new(&[1])], &[1]),
 467         (vec![IoSlice::new(&[1, 2])], &[1, 2]),
 468         (vec![IoSlice::new(&[1, 2, 3])], &[1, 2, 3]),
 469         (vec![IoSlice::new(&[1, 2, 3, 4])], &[1, 2, 3, 4]),
 470         (vec![IoSlice::new(&[1, 2, 3, 4, 5])], &[1, 2, 3, 4, 5]),
 471         (vec![IoSlice::new(&[1]), IoSlice::new(&[2])], &[1, 2]),
 472         (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2])], &[1, 2, 2]),
 473         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2])], &[1, 1, 2, 2]),
 474         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
 475         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 2, 2, 2]),
 476         (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2])], &[1, 1, 1, 2, 2, 2]),
 477         (vec![IoSlice::new(&[1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 2, 2, 2, 2]),
 478         (vec![IoSlice::new(&[1, 1, 1, 1]), IoSlice::new(&[2, 2, 2, 2])], &[1, 1, 1, 1, 2, 2, 2, 2]),
 479         (vec![IoSlice::new(&[1]), IoSlice::new(&[2]), IoSlice::new(&[3])], &[1, 2, 3]),
 480         (vec![IoSlice::new(&[1, 1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3])], &[1, 1, 2, 2, 3, 3]),
 481         (vec![IoSlice::new(&[1]), IoSlice::new(&[2, 2]), IoSlice::new(&[3, 3, 3])], &[1, 2, 2, 3, 3, 3]),
 482         (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]),
 483     ];
 484
 485     let writer_configs = &[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)];
 486
 487     for (n_bufs, per_call) in writer_configs.iter().copied() {
 488         for (mut input, wanted) in tests.clone().into_iter() {
 489             let mut writer = test_writer(n_bufs, per_call);
 490             assert!(writer.write_all_vectored(&mut *input).is_ok());
 491             assert_eq!(&*writer.written, &*wanted);
 492         }
 493     }
 494 }