src/libstd/io/buffered.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10 //
  11 // ignore-lexer-test FIXME #15883
  12
  13 //! Buffering wrappers for I/O traits
  14
  15 use cmp;
  16 use collections::Collection;
  17 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
  18 use iter::ExactSize;
  19 use ops::Drop;
  20 use option::{Some, None, Option};
  21 use result::{Ok, Err};
  22 use slice::{ImmutableSlice, MutableSlice};
  23 use slice;
  24 use vec::Vec;
  25
  26 /// Wraps a Reader and buffers input from it
  27 ///
  28 /// It can be excessively inefficient to work directly with a `Reader`. For
  29 /// example, every call to `read` on `TcpStream` results in a system call. A
  30 /// `BufferedReader` performs large, infrequent reads on the underlying
  31 /// `Reader` and maintains an in-memory buffer of the results.
  32 ///
  33 /// # Example
  34 ///
  35 /// ```rust
  36 /// use std::io::{BufferedReader, File};
  37 ///
  38 /// let file = File::open(&Path::new("message.txt"));
  39 /// let mut reader = BufferedReader::new(file);
  40 ///
  41 /// let mut buf = [0, ..100];
  42 /// match reader.read(buf) {
  43 ///     Ok(nread) => println!("Read {} bytes", nread),
  44 ///     Err(e) => println!("error reading: {}", e)
  45 /// }
  46 /// ```
  47 pub struct BufferedReader<R> {
  48     inner: R,
  49     buf: Vec<u8>,
  50     pos: uint,
  51     cap: uint,
  52 }
  53
  54 impl<R: Reader> BufferedReader<R> {
  55     /// Creates a new `BufferedReader` with the specified buffer capacity
  56     pub fn with_capacity(cap: uint, inner: R) -> BufferedReader<R> {
  57         // It's *much* faster to create an uninitialized buffer than it is to
  58         // fill everything in with 0. This buffer is entirely an implementation
  59         // detail and is never exposed, so we're safe to not initialize
  60         // everything up-front. This allows creation of BufferedReader instances
  61         // to be very cheap (large mallocs are not nearly as expensive as large
  62         // callocs).
  63         let mut buf = Vec::with_capacity(cap);
  64         unsafe { buf.set_len(cap); }
  65         BufferedReader {
  66             inner: inner,
  67             buf: buf,
  68             pos: 0,
  69             cap: 0,
  70         }
  71     }
  72
  73     /// Creates a new `BufferedReader` with a default buffer capacity
  74     pub fn new(inner: R) -> BufferedReader<R> {
  75         BufferedReader::with_capacity(DEFAULT_BUF_SIZE, inner)
  76     }
  77
  78     /// Gets a reference to the underlying reader.
  79     ///
  80     /// This type does not expose the ability to get a mutable reference to the
  81     /// underlying reader because that could possibly corrupt the buffer.
  82     pub fn get_ref<'a>(&'a self) -> &'a R { &self.inner }
  83
  84     /// Unwraps this `BufferedReader`, returning the underlying reader.
  85     ///
  86     /// Note that any leftover data in the internal buffer is lost.
  87     pub fn unwrap(self) -> R { self.inner }
  88 }
  89
  90 impl<R: Reader> Buffer for BufferedReader<R> {
  91     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
  92         if self.pos == self.cap {
  93             self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
  94             self.pos = 0;
  95         }
  96         Ok(self.buf.slice(self.pos, self.cap))
  97     }
  98
  99     fn consume(&mut self, amt: uint) {
 100         self.pos += amt;
 101         assert!(self.pos <= self.cap);
 102     }
 103 }
 104
 105 impl<R: Reader> Reader for BufferedReader<R> {
 106     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 107         let nread = {
 108             let available = try!(self.fill_buf());
 109             let nread = cmp::min(available.len(), buf.len());
 110             slice::bytes::copy_memory(buf, available.slice_to(nread));
 111             nread
 112         };
 113         self.pos += nread;
 114         Ok(nread)
 115     }
 116 }
 117
 118 /// Wraps a Writer and buffers output to it
 119 ///
 120 /// It can be excessively inefficient to work directly with a `Writer`. For
 121 /// example, every call to `write` on `TcpStream` results in a system call. A
 122 /// `BufferedWriter` keeps an in memory buffer of data and writes it to the
 123 /// underlying `Writer` in large, infrequent batches.
 124 ///
 125 /// This writer will be flushed when it is dropped.
 126 ///
 127 /// # Example
 128 ///
 129 /// ```rust
 130 /// # #![allow(unused_must_use)]
 131 /// use std::io::{BufferedWriter, File};
 132 ///
 133 /// let file = File::open(&Path::new("message.txt"));
 134 /// let mut writer = BufferedWriter::new(file);
 135 ///
 136 /// writer.write_str("hello, world");
 137 /// writer.flush();
 138 /// ```
 139 pub struct BufferedWriter<W> {
 140     inner: Option<W>,
 141     buf: Vec<u8>,
 142     pos: uint
 143 }
 144
 145 impl<W: Writer> BufferedWriter<W> {
 146     /// Creates a new `BufferedWriter` with the specified buffer capacity
 147     pub fn with_capacity(cap: uint, inner: W) -> BufferedWriter<W> {
 148         // See comments in BufferedReader for why this uses unsafe code.
 149         let mut buf = Vec::with_capacity(cap);
 150         unsafe { buf.set_len(cap); }
 151         BufferedWriter {
 152             inner: Some(inner),
 153             buf: buf,
 154             pos: 0
 155         }
 156     }
 157
 158     /// Creates a new `BufferedWriter` with a default buffer capacity
 159     pub fn new(inner: W) -> BufferedWriter<W> {
 160         BufferedWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
 161     }
 162
 163     fn flush_buf(&mut self) -> IoResult<()> {
 164         if self.pos != 0 {
 165             let ret = self.inner.get_mut_ref().write(self.buf.slice_to(self.pos));
 166             self.pos = 0;
 167             ret
 168         } else {
 169             Ok(())
 170         }
 171     }
 172
 173     /// Gets a reference to the underlying writer.
 174     ///
 175     /// This type does not expose the ability to get a mutable reference to the
 176     /// underlying reader because that could possibly corrupt the buffer.
 177     pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
 178
 179     /// Unwraps this `BufferedWriter`, returning the underlying writer.
 180     ///
 181     /// The buffer is flushed before returning the writer.
 182     pub fn unwrap(mut self) -> W {
 183         // FIXME(#12628): is failing the right thing to do if flushing fails?
 184         self.flush_buf().unwrap();
 185         self.inner.take_unwrap()
 186     }
 187 }
 188
 189 impl<W: Writer> Writer for BufferedWriter<W> {
 190     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 191         if self.pos + buf.len() > self.buf.len() {
 192             try!(self.flush_buf());
 193         }
 194
 195         if buf.len() > self.buf.len() {
 196             self.inner.get_mut_ref().write(buf)
 197         } else {
 198             let dst = self.buf.mut_slice_from(self.pos);
 199             slice::bytes::copy_memory(dst, buf);
 200             self.pos += buf.len();
 201             Ok(())
 202         }
 203     }
 204
 205     fn flush(&mut self) -> IoResult<()> {
 206         self.flush_buf().and_then(|()| self.inner.get_mut_ref().flush())
 207     }
 208 }
 209
 210 #[unsafe_destructor]
 211 impl<W: Writer> Drop for BufferedWriter<W> {
 212     fn drop(&mut self) {
 213         if self.inner.is_some() {
 214             // dtors should not fail, so we ignore a failed flush
 215             let _ = self.flush_buf();
 216         }
 217     }
 218 }
 219
 220 /// Wraps a Writer and buffers output to it, flushing whenever a newline (`0x0a`,
 221 /// `'\n'`) is detected.
 222 ///
 223 /// This writer will be flushed when it is dropped.
 224 pub struct LineBufferedWriter<W> {
 225     inner: BufferedWriter<W>,
 226 }
 227
 228 impl<W: Writer> LineBufferedWriter<W> {
 229     /// Creates a new `LineBufferedWriter`
 230     pub fn new(inner: W) -> LineBufferedWriter<W> {
 231         // Lines typically aren't that long, don't use a giant buffer
 232         LineBufferedWriter {
 233             inner: BufferedWriter::with_capacity(1024, inner)
 234         }
 235     }
 236
 237     /// Gets a reference to the underlying writer.
 238     ///
 239     /// This type does not expose the ability to get a mutable reference to the
 240     /// underlying reader because that could possibly corrupt the buffer.
 241     pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
 242
 243     /// Unwraps this `LineBufferedWriter`, returning the underlying writer.
 244     ///
 245     /// The internal buffer is flushed before returning the writer.
 246     pub fn unwrap(self) -> W { self.inner.unwrap() }
 247 }
 248
 249 impl<W: Writer> Writer for LineBufferedWriter<W> {
 250     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 251         match buf.iter().rposition(|&b| b == b'\n') {
 252             Some(i) => {
 253                 try!(self.inner.write(buf.slice_to(i + 1)));
 254                 try!(self.inner.flush());
 255                 try!(self.inner.write(buf.slice_from(i + 1)));
 256                 Ok(())
 257             }
 258             None => self.inner.write(buf),
 259         }
 260     }
 261
 262     fn flush(&mut self) -> IoResult<()> { self.inner.flush() }
 263 }
 264
 265 struct InternalBufferedWriter<W>(BufferedWriter<W>);
 266
 267 impl<W> InternalBufferedWriter<W> {
 268     fn get_mut_ref<'a>(&'a mut self) -> &'a mut BufferedWriter<W> {
 269         let InternalBufferedWriter(ref mut w) = *self;
 270         return w;
 271     }
 272 }
 273
 274 impl<W: Reader> Reader for InternalBufferedWriter<W> {
 275     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 276         self.get_mut_ref().inner.get_mut_ref().read(buf)
 277     }
 278 }
 279
 280 /// Wraps a Stream and buffers input and output to and from it.
 281 ///
 282 /// It can be excessively inefficient to work directly with a `Stream`. For
 283 /// example, every call to `read` or `write` on `TcpStream` results in a system
 284 /// call. A `BufferedStream` keeps in memory buffers of data, making large,
 285 /// infrequent calls to `read` and `write` on the underlying `Stream`.
 286 ///
 287 /// The output half will be flushed when this stream is dropped.
 288 ///
 289 /// # Example
 290 ///
 291 /// ```rust
 292 /// # #![allow(unused_must_use)]
 293 /// use std::io::{BufferedStream, File};
 294 ///
 295 /// let file = File::open(&Path::new("message.txt"));
 296 /// let mut stream = BufferedStream::new(file);
 297 ///
 298 /// stream.write("hello, world".as_bytes());
 299 /// stream.flush();
 300 ///
 301 /// let mut buf = [0, ..100];
 302 /// match stream.read(buf) {
 303 ///     Ok(nread) => println!("Read {} bytes", nread),
 304 ///     Err(e) => println!("error reading: {}", e)
 305 /// }
 306 /// ```
 307 pub struct BufferedStream<S> {
 308     inner: BufferedReader<InternalBufferedWriter<S>>
 309 }
 310
 311 impl<S: Stream> BufferedStream<S> {
 312     /// Creates a new buffered stream with explicitly listed capacities for the
 313     /// reader/writer buffer.
 314     pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S)
 315                            -> BufferedStream<S> {
 316         let writer = BufferedWriter::with_capacity(writer_cap, inner);
 317         let internal_writer = InternalBufferedWriter(writer);
 318         let reader = BufferedReader::with_capacity(reader_cap,
 319                                                    internal_writer);
 320         BufferedStream { inner: reader }
 321     }
 322
 323     /// Creates a new buffered stream with the default reader/writer buffer
 324     /// capacities.
 325     pub fn new(inner: S) -> BufferedStream<S> {
 326         BufferedStream::with_capacities(DEFAULT_BUF_SIZE, DEFAULT_BUF_SIZE,
 327                                         inner)
 328     }
 329
 330     /// Gets a reference to the underlying stream.
 331     ///
 332     /// This type does not expose the ability to get a mutable reference to the
 333     /// underlying reader because that could possibly corrupt the buffer.
 334     pub fn get_ref<'a>(&'a self) -> &'a S {
 335         let InternalBufferedWriter(ref w) = self.inner.inner;
 336         w.get_ref()
 337     }
 338
 339     /// Unwraps this `BufferedStream`, returning the underlying stream.
 340     ///
 341     /// The internal buffer is flushed before returning the stream. Any leftover
 342     /// data in the read buffer is lost.
 343     pub fn unwrap(self) -> S {
 344         let InternalBufferedWriter(w) = self.inner.inner;
 345         w.unwrap()
 346     }
 347 }
 348
 349 impl<S: Stream> Buffer for BufferedStream<S> {
 350     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> { self.inner.fill_buf() }
 351     fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
 352 }
 353
 354 impl<S: Stream> Reader for BufferedStream<S> {
 355     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 356         self.inner.read(buf)
 357     }
 358 }
 359
 360 impl<S: Stream> Writer for BufferedStream<S> {
 361     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
 362         self.inner.inner.get_mut_ref().write(buf)
 363     }
 364     fn flush(&mut self) -> IoResult<()> {
 365         self.inner.inner.get_mut_ref().flush()
 366     }
 367 }
 368
 369 #[cfg(test)]
 370 mod test {
 371     extern crate test;
 372     use io;
 373     use prelude::*;
 374     use super::*;
 375     use super::super::{IoResult, EndOfFile};
 376     use super::super::mem::{MemReader, MemWriter, BufReader};
 377     use self::test::Bencher;
 378     use str::StrSlice;
 379
 380     /// A type, free to create, primarily intended for benchmarking creation of
 381     /// wrappers that, just for construction, don't need a Reader/Writer that
 382     /// does anything useful. Is equivalent to `/dev/null` in semantics.
 383     #[deriving(Clone,PartialEq,PartialOrd)]
 384     pub struct NullStream;
 385
 386     impl Reader for NullStream {
 387         fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 388             Err(io::standard_error(io::EndOfFile))
 389         }
 390     }
 391
 392     impl Writer for NullStream {
 393         fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
 394     }
 395
 396     /// A dummy reader intended at testing short-reads propagation.
 397     pub struct ShortReader {
 398         lengths: Vec<uint>,
 399     }
 400
 401     impl Reader for ShortReader {
 402         fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 403             match self.lengths.shift() {
 404                 Some(i) => Ok(i),
 405                 None => Err(io::standard_error(io::EndOfFile))
 406             }
 407         }
 408     }
 409
 410     #[test]
 411     fn test_buffered_reader() {
 412         let inner = MemReader::new(vec!(0, 1, 2, 3, 4));
 413         let mut reader = BufferedReader::with_capacity(2, inner);
 414
 415         let mut buf = [0, 0, 0];
 416         let nread = reader.read(buf);
 417         assert_eq!(Ok(2), nread);
 418         assert_eq!(buf.as_slice(), &[0, 1, 0]);
 419
 420         let mut buf = [0];
 421         let nread = reader.read(buf);
 422         assert_eq!(Ok(1), nread);
 423         assert_eq!(buf.as_slice(), &[2]);
 424
 425         let mut buf = [0, 0, 0];
 426         let nread = reader.read(buf);
 427         assert_eq!(Ok(1), nread);
 428         assert_eq!(buf.as_slice(), &[3, 0, 0]);
 429
 430         let nread = reader.read(buf);
 431         assert_eq!(Ok(1), nread);
 432         assert_eq!(buf.as_slice(), &[4, 0, 0]);
 433
 434         assert!(reader.read(buf).is_err());
 435     }
 436
 437     #[test]
 438     fn test_buffered_writer() {
 439         let inner = MemWriter::new();
 440         let mut writer = BufferedWriter::with_capacity(2, inner);
 441
 442         writer.write([0, 1]).unwrap();
 443         assert_eq!(writer.get_ref().get_ref(), &[]);
 444
 445         writer.write([2]).unwrap();
 446         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 447
 448         writer.write([3]).unwrap();
 449         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 450
 451         writer.flush().unwrap();
 452         assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 453
 454         writer.write([4]).unwrap();
 455         writer.write([5]).unwrap();
 456         assert_eq!(&[0, 1, 2, 3], writer.get_ref().get_ref());
 457
 458         writer.write([6]).unwrap();
 459         assert_eq!(&[0, 1, 2, 3, 4, 5],
 460                    writer.get_ref().get_ref());
 461
 462         writer.write([7, 8]).unwrap();
 463         assert_eq!(&[0, 1, 2, 3, 4, 5, 6],
 464                    writer.get_ref().get_ref());
 465
 466         writer.write([9, 10, 11]).unwrap();
 467         assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
 468                    writer.get_ref().get_ref());
 469
 470         writer.flush().unwrap();
 471         assert_eq!(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
 472                    writer.get_ref().get_ref());
 473     }
 474
 475     #[test]
 476     fn test_buffered_writer_inner_flushes() {
 477         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
 478         w.write([0, 1]).unwrap();
 479         assert_eq!(&[], w.get_ref().get_ref());
 480         let w = w.unwrap();
 481         assert_eq!(&[0, 1], w.get_ref());
 482     }
 483
 484     // This is just here to make sure that we don't infinite loop in the
 485     // newtype struct autoderef weirdness
 486     #[test]
 487     fn test_buffered_stream() {
 488         struct S;
 489
 490         impl io::Writer for S {
 491             fn write(&mut self, _: &[u8]) -> io::IoResult<()> { Ok(()) }
 492         }
 493
 494         impl io::Reader for S {
 495             fn read(&mut self, _: &mut [u8]) -> io::IoResult<uint> {
 496                 Err(io::standard_error(io::EndOfFile))
 497             }
 498         }
 499
 500         let mut stream = BufferedStream::new(S);
 501         let mut buf = [];
 502         assert!(stream.read(buf).is_err());
 503         stream.write(buf).unwrap();
 504         stream.flush().unwrap();
 505     }
 506
 507     #[test]
 508     fn test_read_until() {
 509         let inner = MemReader::new(vec!(0, 1, 2, 1, 0));
 510         let mut reader = BufferedReader::with_capacity(2, inner);
 511         assert_eq!(reader.read_until(0), Ok(vec!(0)));
 512         assert_eq!(reader.read_until(2), Ok(vec!(1, 2)));
 513         assert_eq!(reader.read_until(1), Ok(vec!(1)));
 514         assert_eq!(reader.read_until(8), Ok(vec!(0)));
 515         assert!(reader.read_until(9).is_err());
 516     }
 517
 518     #[test]
 519     fn test_line_buffer() {
 520         let mut writer = LineBufferedWriter::new(MemWriter::new());
 521         writer.write([0]).unwrap();
 522         assert_eq!(writer.get_ref().get_ref(), &[]);
 523         writer.write([1]).unwrap();
 524         assert_eq!(writer.get_ref().get_ref(), &[]);
 525         writer.flush().unwrap();
 526         assert_eq!(writer.get_ref().get_ref(), &[0, 1]);
 527         writer.write([0, b'\n', 1, b'\n', 2]).unwrap();
 528         assert_eq!(writer.get_ref().get_ref(),
 529                    &[0, 1, 0, b'\n', 1, b'\n']);
 530         writer.flush().unwrap();
 531         assert_eq!(writer.get_ref().get_ref(),
 532                    &[0, 1, 0, b'\n', 1, b'\n', 2]);
 533         writer.write([3, b'\n']).unwrap();
 534         assert_eq!(writer.get_ref().get_ref(),
 535             &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
 536     }
 537
 538     #[test]
 539     fn test_read_line() {
 540         let in_buf = MemReader::new(Vec::from_slice(b"a\nb\nc"));
 541         let mut reader = BufferedReader::with_capacity(2, in_buf);
 542         assert_eq!(reader.read_line(), Ok("a\n".to_string()));
 543         assert_eq!(reader.read_line(), Ok("b\n".to_string()));
 544         assert_eq!(reader.read_line(), Ok("c".to_string()));
 545         assert!(reader.read_line().is_err());
 546     }
 547
 548     #[test]
 549     fn test_lines() {
 550         let in_buf = MemReader::new(Vec::from_slice(b"a\nb\nc"));
 551         let mut reader = BufferedReader::with_capacity(2, in_buf);
 552         let mut it = reader.lines();
 553         assert_eq!(it.next(), Some(Ok("a\n".to_string())));
 554         assert_eq!(it.next(), Some(Ok("b\n".to_string())));
 555         assert_eq!(it.next(), Some(Ok("c".to_string())));
 556         assert_eq!(it.next(), None);
 557     }
 558
 559     #[test]
 560     fn test_short_reads() {
 561         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
 562         let mut reader = BufferedReader::new(inner);
 563         let mut buf = [0, 0];
 564         assert_eq!(reader.read(buf), Ok(0));
 565         assert_eq!(reader.read(buf), Ok(1));
 566         assert_eq!(reader.read(buf), Ok(2));
 567         assert_eq!(reader.read(buf), Ok(0));
 568         assert_eq!(reader.read(buf), Ok(1));
 569         assert_eq!(reader.read(buf), Ok(0));
 570         assert!(reader.read(buf).is_err());
 571     }
 572
 573     #[test]
 574     fn read_char_buffered() {
 575         let buf = [195u8, 159u8];
 576         let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
 577         assert_eq!(reader.read_char(), Ok('ß'));
 578     }
 579
 580     #[test]
 581     fn test_chars() {
 582         let buf = [195u8, 159u8, b'a'];
 583         let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
 584         let mut it = reader.chars();
 585         assert_eq!(it.next(), Some(Ok('ß')));
 586         assert_eq!(it.next(), Some(Ok('a')));
 587         assert_eq!(it.next(), None);
 588     }
 589
 590     #[test]
 591     #[should_fail]
 592     fn dont_fail_in_drop_on_failed_flush() {
 593         struct FailFlushWriter;
 594
 595         impl Writer for FailFlushWriter {
 596             fn write(&mut self, _buf: &[u8]) -> IoResult<()> { Ok(()) }
 597             fn flush(&mut self) -> IoResult<()> { Err(io::standard_error(EndOfFile)) }
 598         }
 599
 600         let writer = FailFlushWriter;
 601         let _writer = BufferedWriter::new(writer);
 602
 603         // Trigger failure. If writer fails *again* due to the flush
 604         // error then the process will abort.
 605         fail!();
 606     }
 607
 608     #[bench]
 609     fn bench_buffered_reader(b: &mut Bencher) {
 610         b.iter(|| {
 611             BufferedReader::new(NullStream)
 612         });
 613     }
 614
 615     #[bench]
 616     fn bench_buffered_writer(b: &mut Bencher) {
 617         b.iter(|| {
 618             BufferedWriter::new(NullStream)
 619         });
 620     }
 621
 622     #[bench]
 623     fn bench_buffered_stream(b: &mut Bencher) {
 624         b.iter(|| {
 625             BufferedStream::new(NullStream);
 626         });
 627     }
 628 }