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