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