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