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 prelude::v1::*;
  16 use io::prelude::*;
  17
  18 use cmp;
  19 use error::Error as StdError;
  20 use error::FromError;
  21 use fmt;
  22 use io::{self, Cursor, DEFAULT_BUF_SIZE, Error, ErrorKind};
  23 use ptr;
  24
  25 /// Wraps a `Read` and buffers input from it
  26 ///
  27 /// It can be excessively inefficient to work directly with a `Read` instance.
  28 /// For example, every call to `read` on `TcpStream` results in a system call.
  29 /// A `BufReader` performs large, infrequent reads on the underlying `Read`
  30 /// and maintains an in-memory buffer of the results.
  31 pub struct BufReader<R> {
  32     inner: R,
  33     buf: Cursor<Vec<u8>>,
  34 }
  35
  36 impl<R: Read> BufReader<R> {
  37     /// Creates a new `BufReader` with a default buffer capacity
  38     pub fn new(inner: R) -> BufReader<R> {
  39         BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
  40     }
  41
  42     /// Creates a new `BufReader` with the specified buffer capacity
  43     pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
  44         BufReader {
  45             inner: inner,
  46             buf: Cursor::new(Vec::with_capacity(cap)),
  47         }
  48     }
  49
  50     /// Gets a reference to the underlying reader.
  51     pub fn get_ref<'a>(&self) -> &R { &self.inner }
  52
  53     /// Gets a mutable reference to the underlying reader.
  54     ///
  55     /// # Warning
  56     ///
  57     /// It is inadvisable to directly read from the underlying reader.
  58     pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
  59
  60     /// Unwraps this `BufReader`, returning the underlying reader.
  61     ///
  62     /// Note that any leftover data in the internal buffer is lost.
  63     pub fn into_inner(self) -> R { self.inner }
  64 }
  65
  66 impl<R: Read> Read for BufReader<R> {
  67     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
  68         // If we don't have any buffered data and we're doing a massive read
  69         // (larger than our internal buffer), bypass our internal buffer
  70         // entirely.
  71         if self.buf.get_ref().len() == self.buf.position() as usize &&
  72             buf.len() >= self.buf.get_ref().capacity() {
  73             return self.inner.read(buf);
  74         }
  75         try!(self.fill_buf());
  76         self.buf.read(buf)
  77     }
  78 }
  79
  80 impl<R: Read> BufRead for BufReader<R> {
  81     fn fill_buf(&mut self) -> io::Result<&[u8]> {
  82         // If we've reached the end of our internal buffer then we need to fetch
  83         // some more data from the underlying reader.
  84         if self.buf.position() as usize == self.buf.get_ref().len() {
  85             self.buf.set_position(0);
  86             let v = self.buf.get_mut();
  87             v.truncate(0);
  88             let inner = &mut self.inner;
  89             try!(super::with_end_to_cap(v, |b| inner.read(b)));
  90         }
  91         self.buf.fill_buf()
  92     }
  93
  94     fn consume(&mut self, amt: uint) {
  95         self.buf.consume(amt)
  96     }
  97 }
  98
  99 #[stable(feature = "rust1", since = "1.0.0")]
 100 impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
 101     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 102         write!(fmt, "BufReader {{ reader: {:?}, buffer: {}/{} }}",
 103                self.inner, self.buf.position(), self.buf.get_ref().len())
 104     }
 105 }
 106
 107 /// Wraps a Writer and buffers output to it
 108 ///
 109 /// It can be excessively inefficient to work directly with a `Write`. For
 110 /// example, every call to `write` on `TcpStream` results in a system call. A
 111 /// `BufWriter` keeps an in memory buffer of data and writes it to the
 112 /// underlying `Write` in large, infrequent batches.
 113 ///
 114 /// This writer will be flushed when it is dropped.
 115 pub struct BufWriter<W> {
 116     inner: Option<W>,
 117     buf: Vec<u8>,
 118 }
 119
 120 /// An error returned by `into_inner` which indicates whether a flush error
 121 /// happened or not.
 122 #[derive(Debug)]
 123 pub struct IntoInnerError<W>(W, Error);
 124
 125 impl<W: Write> BufWriter<W> {
 126     /// Creates a new `BufWriter` with a default buffer capacity
 127     pub fn new(inner: W) -> BufWriter<W> {
 128         BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
 129     }
 130
 131     /// Creates a new `BufWriter` with the specified buffer capacity
 132     pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
 133         BufWriter {
 134             inner: Some(inner),
 135             buf: Vec::with_capacity(cap),
 136         }
 137     }
 138
 139     fn flush_buf(&mut self) -> io::Result<()> {
 140         let mut written = 0;
 141         let len = self.buf.len();
 142         let mut ret = Ok(());
 143         while written < len {
 144             match self.inner.as_mut().unwrap().write(&self.buf[written..]) {
 145                 Ok(0) => {
 146                     ret = Err(Error::new(ErrorKind::WriteZero,
 147                                          "failed to flush", None));
 148                     break;
 149                 }
 150                 Ok(n) => written += n,
 151                 Err(e) => { ret = Err(e); break }
 152
 153             }
 154         }
 155         if written > 0 {
 156             // NB: would be better expressed as .remove(0..n) if it existed
 157             unsafe {
 158                 ptr::copy_memory(self.buf.as_mut_ptr(),
 159                                  self.buf.as_ptr().offset(written as isize),
 160                                  len - written);
 161             }
 162         }
 163         self.buf.truncate(len - written);
 164         ret
 165     }
 166
 167     /// Gets a reference to the underlying writer.
 168     pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
 169
 170     /// Gets a mutable reference to the underlying write.
 171     ///
 172     /// # Warning
 173     ///
 174     /// It is inadvisable to directly read from the underlying writer.
 175     pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
 176
 177     /// Unwraps this `BufWriter`, returning the underlying writer.
 178     ///
 179     /// The buffer is flushed before returning the writer.
 180     pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
 181         match self.flush_buf() {
 182             Err(e) => Err(IntoInnerError(self, e)),
 183             Ok(()) => Ok(self.inner.take().unwrap())
 184         }
 185     }
 186 }
 187
 188 impl<W: Write> Write for BufWriter<W> {
 189     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 190         if self.buf.len() + buf.len() > self.buf.capacity() {
 191             try!(self.flush_buf());
 192         }
 193         if buf.len() >= self.buf.capacity() {
 194             self.inner.as_mut().unwrap().write(buf)
 195         } else {
 196             let amt = cmp::min(buf.len(), self.buf.capacity());
 197             Write::write(&mut self.buf, &buf[..amt])
 198         }
 199     }
 200     fn flush(&mut self) -> io::Result<()> {
 201         self.flush_buf().and_then(|()| self.get_mut().flush())
 202     }
 203 }
 204
 205 #[stable(feature = "rust1", since = "1.0.0")]
 206 impl<W> fmt::Debug for BufWriter<W> where W: fmt::Debug {
 207     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 208         write!(fmt, "BufWriter {{ writer: {:?}, buffer: {}/{} }}",
 209                self.inner.as_ref().unwrap(), self.buf.len(), self.buf.capacity())
 210     }
 211 }
 212
 213 #[unsafe_destructor]
 214 impl<W: Write> Drop for BufWriter<W> {
 215     fn drop(&mut self) {
 216         if self.inner.is_some() {
 217             // dtors should not panic, so we ignore a failed flush
 218             let _r = self.flush_buf();
 219         }
 220     }
 221 }
 222
 223 impl<W> IntoInnerError<W> {
 224     /// Returns the error which caused the call to `into_inner` to fail.
 225     ///
 226     /// This error was returned when attempting to flush the internal buffer.
 227     pub fn error(&self) -> &Error { &self.1 }
 228
 229     /// Returns the underlying `BufWriter` instance which generated the error.
 230     ///
 231     /// The returned object can be used to retry a flush or re-inspect the
 232     /// buffer.
 233     pub fn into_inner(self) -> W { self.0 }
 234 }
 235
 236 impl<W> FromError<IntoInnerError<W>> for Error {
 237     fn from_error(iie: IntoInnerError<W>) -> Error { iie.1 }
 238 }
 239
 240 impl<W> StdError for IntoInnerError<W> {
 241     fn description(&self) -> &str { self.error().description() }
 242 }
 243
 244 impl<W> fmt::Display for IntoInnerError<W> {
 245     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 246         self.error().fmt(f)
 247     }
 248 }
 249
 250 /// Wraps a Writer and buffers output to it, flushing whenever a newline
 251 /// (`0x0a`, `'\n'`) is detected.
 252 ///
 253 /// This writer will be flushed when it is dropped.
 254 pub struct LineWriter<W> {
 255     inner: BufWriter<W>,
 256 }
 257
 258 impl<W: Write> LineWriter<W> {
 259     /// Creates a new `LineWriter`
 260     pub fn new(inner: W) -> LineWriter<W> {
 261         // Lines typically aren't that long, don't use a giant buffer
 262         LineWriter { inner: BufWriter::with_capacity(1024, inner) }
 263     }
 264
 265     /// Gets a reference to the underlying writer.
 266     ///
 267     /// This type does not expose the ability to get a mutable reference to the
 268     /// underlying reader because that could possibly corrupt the buffer.
 269     pub fn get_ref<'a>(&'a self) -> &'a W { self.inner.get_ref() }
 270
 271     /// Unwraps this `LineWriter`, returning the underlying writer.
 272     ///
 273     /// The internal buffer is flushed before returning the writer.
 274     pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
 275         self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
 276             IntoInnerError(LineWriter { inner: buf }, e)
 277         })
 278     }
 279 }
 280
 281 impl<W: Write> Write for LineWriter<W> {
 282     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 283         match buf.rposition_elem(&b'\n') {
 284             Some(i) => {
 285                 let n = try!(self.inner.write(&buf[..i + 1]));
 286                 if n != i + 1 { return Ok(n) }
 287                 try!(self.inner.flush());
 288                 self.inner.write(&buf[i + 1..]).map(|i| n + i)
 289             }
 290             None => self.inner.write(buf),
 291         }
 292     }
 293
 294     fn flush(&mut self) -> io::Result<()> { self.inner.flush() }
 295 }
 296
 297 #[stable(feature = "rust1", since = "1.0.0")]
 298 impl<W> fmt::Debug for LineWriter<W> where W: fmt::Debug {
 299     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 300         write!(fmt, "LineWriter {{ writer: {:?}, buffer: {}/{} }}",
 301                self.inner.inner, self.inner.buf.len(),
 302                self.inner.buf.capacity())
 303     }
 304 }
 305
 306 struct InternalBufWriter<W>(BufWriter<W>);
 307
 308 impl<W> InternalBufWriter<W> {
 309     fn get_mut(&mut self) -> &mut BufWriter<W> {
 310         let InternalBufWriter(ref mut w) = *self;
 311         return w;
 312     }
 313 }
 314
 315 impl<W: Read> Read for InternalBufWriter<W> {
 316     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 317         self.get_mut().inner.as_mut().unwrap().read(buf)
 318     }
 319 }
 320
 321 /// Wraps a Stream and buffers input and output to and from it.
 322 ///
 323 /// It can be excessively inefficient to work directly with a `Stream`. For
 324 /// example, every call to `read` or `write` on `TcpStream` results in a system
 325 /// call. A `BufStream` keeps in memory buffers of data, making large,
 326 /// infrequent calls to `read` and `write` on the underlying `Stream`.
 327 ///
 328 /// The output half will be flushed when this stream is dropped.
 329 pub struct BufStream<S> {
 330     inner: BufReader<InternalBufWriter<S>>
 331 }
 332
 333 impl<S: Read + Write> BufStream<S> {
 334     /// Creates a new buffered stream with explicitly listed capacities for the
 335     /// reader/writer buffer.
 336     pub fn with_capacities(reader_cap: usize, writer_cap: usize, inner: S)
 337                            -> BufStream<S> {
 338         let writer = BufWriter::with_capacity(writer_cap, inner);
 339         let internal_writer = InternalBufWriter(writer);
 340         let reader = BufReader::with_capacity(reader_cap, internal_writer);
 341         BufStream { inner: reader }
 342     }
 343
 344     /// Creates a new buffered stream with the default reader/writer buffer
 345     /// capacities.
 346     pub fn new(inner: S) -> BufStream<S> {
 347         BufStream::with_capacities(DEFAULT_BUF_SIZE, DEFAULT_BUF_SIZE, inner)
 348     }
 349
 350     /// Gets a reference to the underlying stream.
 351     pub fn get_ref(&self) -> &S {
 352         let InternalBufWriter(ref w) = self.inner.inner;
 353         w.get_ref()
 354     }
 355
 356     /// Gets a mutable reference to the underlying stream.
 357     ///
 358     /// # Warning
 359     ///
 360     /// It is inadvisable to read directly from or write directly to the
 361     /// underlying stream.
 362     pub fn get_mut(&mut self) -> &mut S {
 363         let InternalBufWriter(ref mut w) = self.inner.inner;
 364         w.get_mut()
 365     }
 366
 367     /// Unwraps this `BufStream`, returning the underlying stream.
 368     ///
 369     /// The internal buffer is flushed before returning the stream. Any leftover
 370     /// data in the read buffer is lost.
 371     pub fn into_inner(self) -> Result<S, IntoInnerError<BufStream<S>>> {
 372         let BufReader { inner: InternalBufWriter(w), buf } = self.inner;
 373         w.into_inner().map_err(|IntoInnerError(w, e)| {
 374             IntoInnerError(BufStream {
 375                 inner: BufReader { inner: InternalBufWriter(w), buf: buf },
 376             }, e)
 377         })
 378     }
 379 }
 380
 381 impl<S: Read + Write> BufRead for BufStream<S> {
 382     fn fill_buf(&mut self) -> io::Result<&[u8]> { self.inner.fill_buf() }
 383     fn consume(&mut self, amt: uint) { self.inner.consume(amt) }
 384 }
 385
 386 impl<S: Read + Write> Read for BufStream<S> {
 387     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 388         self.inner.read(buf)
 389     }
 390 }
 391
 392 impl<S: Read + Write> Write for BufStream<S> {
 393     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 394         self.inner.inner.get_mut().write(buf)
 395     }
 396     fn flush(&mut self) -> io::Result<()> {
 397         self.inner.inner.get_mut().flush()
 398     }
 399 }
 400
 401 #[stable(feature = "rust1", since = "1.0.0")]
 402 impl<S> fmt::Debug for BufStream<S> where S: fmt::Debug {
 403     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 404         let reader = &self.inner;
 405         let writer = &self.inner.inner.0;
 406         write!(fmt, "BufStream {{ stream: {:?}, write_buffer: {}/{}, read_buffer: {}/{} }}",
 407                writer.inner,
 408                writer.buf.len(), writer.buf.capacity(),
 409                reader.buf.position(), reader.buf.get_ref().len())
 410     }
 411 }
 412
 413 #[cfg(test)]
 414 mod tests {
 415     use prelude::v1::*;
 416     use io::prelude::*;
 417     use io::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter};
 418     use test;
 419
 420     /// A dummy reader intended at testing short-reads propagation.
 421     pub struct ShortReader {
 422         lengths: Vec<usize>,
 423     }
 424
 425     impl Read for ShortReader {
 426         fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
 427             if self.lengths.is_empty() {
 428                 Ok(0)
 429             } else {
 430                 Ok(self.lengths.remove(0))
 431             }
 432         }
 433     }
 434
 435     #[test]
 436     fn test_buffered_reader() {
 437         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
 438         let mut reader = BufReader::with_capacity(2, inner);
 439
 440         let mut buf = [0, 0, 0];
 441         let nread = reader.read(&mut buf);
 442         assert_eq!(Ok(3), nread);
 443         let b: &[_] = &[5, 6, 7];
 444         assert_eq!(buf, b);
 445
 446         let mut buf = [0, 0];
 447         let nread = reader.read(&mut buf);
 448         assert_eq!(Ok(2), nread);
 449         let b: &[_] = &[0, 1];
 450         assert_eq!(buf, b);
 451
 452         let mut buf = [0];
 453         let nread = reader.read(&mut buf);
 454         assert_eq!(Ok(1), nread);
 455         let b: &[_] = &[2];
 456         assert_eq!(buf, b);
 457
 458         let mut buf = [0, 0, 0];
 459         let nread = reader.read(&mut buf);
 460         assert_eq!(Ok(1), nread);
 461         let b: &[_] = &[3, 0, 0];
 462         assert_eq!(buf, b);
 463
 464         let nread = reader.read(&mut buf);
 465         assert_eq!(Ok(1), nread);
 466         let b: &[_] = &[4, 0, 0];
 467         assert_eq!(buf, b);
 468
 469         assert_eq!(reader.read(&mut buf), Ok(0));
 470     }
 471
 472     #[test]
 473     fn test_buffered_writer() {
 474         let inner = Vec::new();
 475         let mut writer = BufWriter::with_capacity(2, inner);
 476
 477         writer.write(&[0, 1]).unwrap();
 478         assert_eq!(*writer.get_ref(), [0, 1]);
 479
 480         writer.write(&[2]).unwrap();
 481         assert_eq!(*writer.get_ref(), [0, 1]);
 482
 483         writer.write(&[3]).unwrap();
 484         assert_eq!(*writer.get_ref(), [0, 1]);
 485
 486         writer.flush().unwrap();
 487         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
 488
 489         writer.write(&[4]).unwrap();
 490         writer.write(&[5]).unwrap();
 491         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
 492
 493         writer.write(&[6]).unwrap();
 494         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
 495
 496         writer.write(&[7, 8]).unwrap();
 497         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
 498
 499         writer.write(&[9, 10, 11]).unwrap();
 500         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
 501         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 502
 503         writer.flush().unwrap();
 504         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 505     }
 506
 507     #[test]
 508     fn test_buffered_writer_inner_flushes() {
 509         let mut w = BufWriter::with_capacity(3, Vec::new());
 510         w.write(&[0, 1]).unwrap();
 511         assert_eq!(*w.get_ref(), []);
 512         let w = w.into_inner().unwrap();
 513         assert_eq!(w, [0, 1]);
 514     }
 515
 516     // This is just here to make sure that we don't infinite loop in the
 517     // newtype struct autoderef weirdness
 518     #[test]
 519     fn test_buffered_stream() {
 520         struct S;
 521
 522         impl Write for S {
 523             fn write(&mut self, b: &[u8]) -> io::Result<usize> { Ok(b.len()) }
 524             fn flush(&mut self) -> io::Result<()> { Ok(()) }
 525         }
 526
 527         impl Read for S {
 528             fn read(&mut self, _: &mut [u8]) -> io::Result<usize> { Ok(0) }
 529         }
 530
 531         let mut stream = BufStream::new(S);
 532         assert_eq!(stream.read(&mut [0; 10]), Ok(0));
 533         stream.write(&[0; 10]).unwrap();
 534         stream.flush().unwrap();
 535     }
 536
 537     #[test]
 538     fn test_read_until() {
 539         let inner: &[u8] = &[0, 1, 2, 1, 0];
 540         let mut reader = BufReader::with_capacity(2, inner);
 541         let mut v = Vec::new();
 542         reader.read_until(0, &mut v).unwrap();
 543         assert_eq!(v, [0]);
 544         v.truncate(0);
 545         reader.read_until(2, &mut v).unwrap();
 546         assert_eq!(v, [1, 2]);
 547         v.truncate(0);
 548         reader.read_until(1, &mut v).unwrap();
 549         assert_eq!(v, [1]);
 550         v.truncate(0);
 551         reader.read_until(8, &mut v).unwrap();
 552         assert_eq!(v, [0]);
 553         v.truncate(0);
 554         reader.read_until(9, &mut v).unwrap();
 555         assert_eq!(v, []);
 556     }
 557
 558     #[test]
 559     fn test_line_buffer() {
 560         let mut writer = LineWriter::new(Vec::new());
 561         writer.write(&[0]).unwrap();
 562         assert_eq!(*writer.get_ref(), []);
 563         writer.write(&[1]).unwrap();
 564         assert_eq!(*writer.get_ref(), []);
 565         writer.flush().unwrap();
 566         assert_eq!(*writer.get_ref(), [0, 1]);
 567         writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
 568         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
 569         writer.flush().unwrap();
 570         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
 571         writer.write(&[3, b'\n']).unwrap();
 572         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
 573     }
 574
 575     #[test]
 576     fn test_read_line() {
 577         let in_buf = b"a\nb\nc";
 578         let mut reader = BufReader::with_capacity(2, in_buf);
 579         let mut s = String::new();
 580         reader.read_line(&mut s).unwrap();
 581         assert_eq!(s, "a\n");
 582         s.truncate(0);
 583         reader.read_line(&mut s).unwrap();
 584         assert_eq!(s, "b\n");
 585         s.truncate(0);
 586         reader.read_line(&mut s).unwrap();
 587         assert_eq!(s, "c");
 588         s.truncate(0);
 589         reader.read_line(&mut s).unwrap();
 590         assert_eq!(s, "");
 591     }
 592
 593     #[test]
 594     fn test_lines() {
 595         let in_buf = b"a\nb\nc";
 596         let mut reader = BufReader::with_capacity(2, in_buf);
 597         let mut it = reader.lines();
 598         assert_eq!(it.next(), Some(Ok("a".to_string())));
 599         assert_eq!(it.next(), Some(Ok("b".to_string())));
 600         assert_eq!(it.next(), Some(Ok("c".to_string())));
 601         assert_eq!(it.next(), None);
 602     }
 603
 604     #[test]
 605     fn test_short_reads() {
 606         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
 607         let mut reader = BufReader::new(inner);
 608         let mut buf = [0, 0];
 609         assert_eq!(reader.read(&mut buf), Ok(0));
 610         assert_eq!(reader.read(&mut buf), Ok(1));
 611         assert_eq!(reader.read(&mut buf), Ok(2));
 612         assert_eq!(reader.read(&mut buf), Ok(0));
 613         assert_eq!(reader.read(&mut buf), Ok(1));
 614         assert_eq!(reader.read(&mut buf), Ok(0));
 615         assert_eq!(reader.read(&mut buf), Ok(0));
 616     }
 617
 618     #[test]
 619     fn read_char_buffered() {
 620         let buf = [195u8, 159u8];
 621         let mut reader = BufReader::with_capacity(1, &buf[]);
 622         assert_eq!(reader.chars().next(), Some(Ok('ß')));
 623     }
 624
 625     #[test]
 626     fn test_chars() {
 627         let buf = [195u8, 159u8, b'a'];
 628         let mut reader = BufReader::with_capacity(1, &buf[]);
 629         let mut it = reader.chars();
 630         assert_eq!(it.next(), Some(Ok('ß')));
 631         assert_eq!(it.next(), Some(Ok('a')));
 632         assert_eq!(it.next(), None);
 633     }
 634
 635     #[test]
 636     #[should_fail]
 637     fn dont_panic_in_drop_on_panicked_flush() {
 638         struct FailFlushWriter;
 639
 640         impl Write for FailFlushWriter {
 641             fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
 642             fn flush(&mut self) -> io::Result<()> {
 643                 Err(io::Error::last_os_error())
 644             }
 645         }
 646
 647         let writer = FailFlushWriter;
 648         let _writer = BufWriter::new(writer);
 649
 650         // If writer panics *again* due to the flush error then the process will
 651         // abort.
 652         panic!();
 653     }
 654
 655     #[bench]
 656     fn bench_buffered_reader(b: &mut test::Bencher) {
 657         b.iter(|| {
 658             BufReader::new(io::empty())
 659         });
 660     }
 661
 662     #[bench]
 663     fn bench_buffered_writer(b: &mut test::Bencher) {
 664         b.iter(|| {
 665             BufWriter::new(io::sink())
 666         });
 667     }
 668
 669     #[bench]
 670     fn bench_buffered_stream(b: &mut test::Bencher) {
 671         let mut buf = Cursor::new(Vec::new());
 672         b.iter(|| {
 673             BufStream::new(&mut buf);
 674         });
 675     }
 676 }