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