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