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

   1 use crate::cmp::{max, min};
   2 use crate::io::prelude::*;
   3 use crate::io::{
   4     copy, empty, repeat, sink, BufWriter, Empty, ReadBuf, Repeat, Result, SeekFrom, Sink,
   5     DEFAULT_BUF_SIZE,
   6 };
   7
   8 use crate::mem::MaybeUninit;
   9
  10 #[test]
  11 fn copy_copies() {
  12     let mut r = repeat(0).take(4);
  13     let mut w = sink();
  14     assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
  15
  16     let mut r = repeat(0).take(1 << 17);
  17     assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17);
  18 }
  19
  20 struct ShortReader {
  21     cap: usize,
  22     read_size: usize,
  23     observed_buffer: usize,
  24 }
  25
  26 impl Read for ShortReader {
  27     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
  28         let bytes = min(self.cap, self.read_size);
  29         self.cap -= bytes;
  30         self.observed_buffer = max(self.observed_buffer, buf.len());
  31         Ok(bytes)
  32     }
  33 }
  34
  35 struct WriteObserver {
  36     observed_buffer: usize,
  37 }
  38
  39 impl Write for WriteObserver {
  40     fn write(&mut self, buf: &[u8]) -> Result<usize> {
  41         self.observed_buffer = max(self.observed_buffer, buf.len());
  42         Ok(buf.len())
  43     }
  44
  45     fn flush(&mut self) -> Result<()> {
  46         Ok(())
  47     }
  48 }
  49
  50 #[test]
  51 fn copy_specializes_bufwriter() {
  52     let cap = 117 * 1024;
  53     let buf_sz = 16 * 1024;
  54     let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 };
  55     let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 });
  56     assert_eq!(
  57         copy(&mut r, &mut w).unwrap(),
  58         cap as u64,
  59         "expected the whole capacity to be copied"
  60     );
  61     assert_eq!(r.observed_buffer, buf_sz, "expected a large buffer to be provided to the reader");
  62     assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, "expected coalesced writes");
  63 }
  64
  65 #[test]
  66 fn sink_sinks() {
  67     let mut s = sink();
  68     assert_eq!(s.write(&[]).unwrap(), 0);
  69     assert_eq!(s.write(&[0]).unwrap(), 1);
  70     assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
  71     assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
  72 }
  73
  74 #[test]
  75 fn empty_reads() {
  76     let mut e = empty();
  77     assert_eq!(e.read(&mut []).unwrap(), 0);
  78     assert_eq!(e.read(&mut [0]).unwrap(), 0);
  79     assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
  80     assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
  81
  82     let mut buf = [];
  83     let mut buf = ReadBuf::uninit(&mut buf);
  84     e.read_buf(&mut buf).unwrap();
  85     assert_eq!(buf.filled_len(), 0);
  86     assert_eq!(buf.initialized_len(), 0);
  87
  88     let mut buf = [MaybeUninit::uninit()];
  89     let mut buf = ReadBuf::uninit(&mut buf);
  90     e.read_buf(&mut buf).unwrap();
  91     assert_eq!(buf.filled_len(), 0);
  92     assert_eq!(buf.initialized_len(), 0);
  93
  94     let mut buf = [MaybeUninit::uninit(); 1024];
  95     let mut buf = ReadBuf::uninit(&mut buf);
  96     e.read_buf(&mut buf).unwrap();
  97     assert_eq!(buf.filled_len(), 0);
  98     assert_eq!(buf.initialized_len(), 0);
  99
 100     let mut buf = [MaybeUninit::uninit(); 1024];
 101     let mut buf = ReadBuf::uninit(&mut buf);
 102     e.by_ref().read_buf(&mut buf).unwrap();
 103     assert_eq!(buf.filled_len(), 0);
 104     assert_eq!(buf.initialized_len(), 0);
 105 }
 106
 107 #[test]
 108 fn empty_seeks() {
 109     let mut e = empty();
 110     assert!(matches!(e.seek(SeekFrom::Start(0)), Ok(0)));
 111     assert!(matches!(e.seek(SeekFrom::Start(1)), Ok(0)));
 112     assert!(matches!(e.seek(SeekFrom::Start(u64::MAX)), Ok(0)));
 113
 114     assert!(matches!(e.seek(SeekFrom::End(i64::MIN)), Ok(0)));
 115     assert!(matches!(e.seek(SeekFrom::End(-1)), Ok(0)));
 116     assert!(matches!(e.seek(SeekFrom::End(0)), Ok(0)));
 117     assert!(matches!(e.seek(SeekFrom::End(1)), Ok(0)));
 118     assert!(matches!(e.seek(SeekFrom::End(i64::MAX)), Ok(0)));
 119
 120     assert!(matches!(e.seek(SeekFrom::Current(i64::MIN)), Ok(0)));
 121     assert!(matches!(e.seek(SeekFrom::Current(-1)), Ok(0)));
 122     assert!(matches!(e.seek(SeekFrom::Current(0)), Ok(0)));
 123     assert!(matches!(e.seek(SeekFrom::Current(1)), Ok(0)));
 124     assert!(matches!(e.seek(SeekFrom::Current(i64::MAX)), Ok(0)));
 125 }
 126
 127 #[test]
 128 fn repeat_repeats() {
 129     let mut r = repeat(4);
 130     let mut b = [0; 1024];
 131     assert_eq!(r.read(&mut b).unwrap(), 1024);
 132     assert!(b.iter().all(|b| *b == 4));
 133 }
 134
 135 #[test]
 136 fn take_some_bytes() {
 137     assert_eq!(repeat(4).take(100).bytes().count(), 100);
 138     assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
 139     assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
 140 }
 141
 142 #[allow(dead_code)]
 143 fn const_utils() {
 144     const _: Empty = empty();
 145     const _: Repeat = repeat(b'c');
 146     const _: Sink = sink();
 147 }