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

   1 use crate::cmp::{max, min};
   2 use crate::collections::VecDeque;
   3 use crate::io;
   4 use crate::io::*;
   5
   6 #[test]
   7 fn copy_copies() {
   8     let mut r = repeat(0).take(4);
   9     let mut w = sink();
  10     assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
  11
  12     let mut r = repeat(0).take(1 << 17);
  13     assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17);
  14 }
  15
  16 struct ShortReader {
  17     cap: usize,
  18     read_size: usize,
  19     observed_buffer: usize,
  20 }
  21
  22 impl Read for ShortReader {
  23     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
  24         let bytes = min(self.cap, self.read_size).min(buf.len());
  25         self.cap -= bytes;
  26         self.observed_buffer = max(self.observed_buffer, buf.len());
  27         Ok(bytes)
  28     }
  29 }
  30
  31 struct WriteObserver {
  32     observed_buffer: usize,
  33 }
  34
  35 impl Write for WriteObserver {
  36     fn write(&mut self, buf: &[u8]) -> Result<usize> {
  37         self.observed_buffer = max(self.observed_buffer, buf.len());
  38         Ok(buf.len())
  39     }
  40
  41     fn flush(&mut self) -> Result<()> {
  42         Ok(())
  43     }
  44 }
  45
  46 #[test]
  47 fn copy_specializes_bufwriter() {
  48     let cap = 117 * 1024;
  49     let buf_sz = 16 * 1024;
  50     let mut r = ShortReader { cap, observed_buffer: 0, read_size: 1337 };
  51     let mut w = BufWriter::with_capacity(buf_sz, WriteObserver { observed_buffer: 0 });
  52     assert_eq!(
  53         copy(&mut r, &mut w).unwrap(),
  54         cap as u64,
  55         "expected the whole capacity to be copied"
  56     );
  57     assert_eq!(r.observed_buffer, buf_sz, "expected a large buffer to be provided to the reader");
  58     assert!(w.get_mut().observed_buffer > DEFAULT_BUF_SIZE, "expected coalesced writes");
  59 }
  60
  61 #[test]
  62 fn copy_specializes_bufreader() {
  63     let mut source = vec![0; 768 * 1024];
  64     source[1] = 42;
  65     let mut buffered = BufReader::with_capacity(256 * 1024, Cursor::new(&mut source));
  66
  67     let mut sink = Vec::new();
  68     assert_eq!(crate::io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
  69     assert_eq!(source.as_slice(), sink.as_slice());
  70
  71     let buf_sz = 71 * 1024;
  72     assert!(buf_sz > DEFAULT_BUF_SIZE, "test precondition");
  73
  74     let mut buffered = BufReader::with_capacity(buf_sz, Cursor::new(&mut source));
  75     let mut sink = WriteObserver { observed_buffer: 0 };
  76     assert_eq!(crate::io::copy(&mut buffered, &mut sink).unwrap(), source.len() as u64);
  77     assert_eq!(
  78         sink.observed_buffer, buf_sz,
  79         "expected a large buffer to be provided to the writer"
  80     );
  81 }
  82
  83 #[test]
  84 fn copy_specializes_to_vec() {
  85     let cap = DEFAULT_BUF_SIZE * 10;
  86     let mut source = ShortReader { cap, observed_buffer: 0, read_size: DEFAULT_BUF_SIZE };
  87     let mut sink = Vec::new();
  88     let copied = io::copy(&mut source, &mut sink).unwrap();
  89     assert_eq!(cap as u64, copied);
  90     assert_eq!(sink.len() as u64, copied);
  91     assert!(
  92         source.observed_buffer > DEFAULT_BUF_SIZE,
  93         "expected a large buffer to be provided to the reader, got {}",
  94         source.observed_buffer
  95     );
  96 }
  97
  98 #[test]
  99 fn copy_specializes_from_vecdeque() {
 100     let mut source = VecDeque::with_capacity(100 * 1024);
 101     for _ in 0..20 * 1024 {
 102         source.push_front(0);
 103     }
 104     for _ in 0..20 * 1024 {
 105         source.push_back(0);
 106     }
 107     let mut sink = WriteObserver { observed_buffer: 0 };
 108     assert_eq!(40 * 1024u64, io::copy(&mut source, &mut sink).unwrap());
 109     assert_eq!(20 * 1024, sink.observed_buffer);
 110 }
 111
 112 #[test]
 113 fn copy_specializes_from_slice() {
 114     let mut source = [1; 60 * 1024].as_slice();
 115     let mut sink = WriteObserver { observed_buffer: 0 };
 116     assert_eq!(60 * 1024u64, io::copy(&mut source, &mut sink).unwrap());
 117     assert_eq!(60 * 1024, sink.observed_buffer);
 118 }
 119
 120 #[cfg(unix)]
 121 mod io_benches {
 122     use crate::fs::File;
 123     use crate::fs::OpenOptions;
 124     use crate::io::prelude::*;
 125     use crate::io::BufReader;
 126
 127     use test::Bencher;
 128
 129     #[bench]
 130     fn bench_copy_buf_reader(b: &mut Bencher) {
 131         let mut file_in = File::open("/dev/zero").expect("opening /dev/zero failed");
 132         // use dyn to avoid specializations unrelated to readbuf
 133         let dyn_in = &mut file_in as &mut dyn Read;
 134         let mut reader = BufReader::with_capacity(256 * 1024, dyn_in.take(0));
 135         let mut writer =
 136             OpenOptions::new().write(true).open("/dev/null").expect("opening /dev/null failed");
 137
 138         const BYTES: u64 = 1024 * 1024;
 139
 140         b.bytes = BYTES;
 141
 142         b.iter(|| {
 143             reader.get_mut().set_limit(BYTES);
 144             crate::io::copy(&mut reader, &mut writer).unwrap()
 145         });
 146     }
 147 }