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