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