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