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 //! Buffering wrappers for I/O traits
  12
  13 use io::prelude::*;
  14
  15 use cmp;
  16 use error;
  17 use fmt;
  18 use io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
  19 use memchr;
  20
  21 /// The `BufReader` struct adds buffering to any reader.
  22 ///
  23 /// It can be excessively inefficient to work directly with a [`Read`] instance.
  24 /// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]
  25 /// results in a system call. A `BufReader` performs large, infrequent reads on
  26 /// the underlying [`Read`] and maintains an in-memory buffer of the results.
  27 ///
  28 /// `BufReader` can improve the speed of programs that make *small* and
  29 /// *repeated* read calls to the same file or network socket.  It does not
  30 /// help when reading very large amounts at once, or reading just one or a few
  31 /// times.  It also provides no advantage when reading from a source that is
  32 /// already in memory, like a `Vec<u8>`.
  33 ///
  34 /// [`Read`]: ../../std/io/trait.Read.html
  35 /// [`TcpStream::read`]: ../../std/net/struct.TcpStream.html#method.read
  36 /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
  37 ///
  38 /// # Examples
  39 ///
  40 /// ```no_run
  41 /// use std::io::prelude::*;
  42 /// use std::io::BufReader;
  43 /// use std::fs::File;
  44 ///
  45 /// fn main() -> std::io::Result<()> {
  46 ///     let f = File::open("log.txt")?;
  47 ///     let mut reader = BufReader::new(f);
  48 ///
  49 ///     let mut line = String::new();
  50 ///     let len = reader.read_line(&mut line)?;
  51 ///     println!("First line is {} bytes long", len);
  52 ///     Ok(())
  53 /// }
  54 /// ```
  55 #[stable(feature = "rust1", since = "1.0.0")]
  56 pub struct BufReader<R> {
  57     inner: R,
  58     buf: Box<[u8]>,
  59     pos: usize,
  60     cap: usize,
  61 }
  62
  63 impl<R: Read> BufReader<R> {
  64     /// Creates a new `BufReader` with a default buffer capacity. The default is currently 8 KB,
  65     /// but may change in the future.
  66     ///
  67     /// # Examples
  68     ///
  69     /// ```no_run
  70     /// use std::io::BufReader;
  71     /// use std::fs::File;
  72     ///
  73     /// fn main() -> std::io::Result<()> {
  74     ///     let f = File::open("log.txt")?;
  75     ///     let reader = BufReader::new(f);
  76     ///     Ok(())
  77     /// }
  78     /// ```
  79     #[stable(feature = "rust1", since = "1.0.0")]
  80     pub fn new(inner: R) -> BufReader<R> {
  81         BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)
  82     }
  83
  84     /// Creates a new `BufReader` with the specified buffer capacity.
  85     ///
  86     /// # Examples
  87     ///
  88     /// Creating a buffer with ten bytes of capacity:
  89     ///
  90     /// ```no_run
  91     /// use std::io::BufReader;
  92     /// use std::fs::File;
  93     ///
  94     /// fn main() -> std::io::Result<()> {
  95     ///     let f = File::open("log.txt")?;
  96     ///     let reader = BufReader::with_capacity(10, f);
  97     ///     Ok(())
  98     /// }
  99     /// ```
 100     #[stable(feature = "rust1", since = "1.0.0")]
 101     pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {
 102         unsafe {
 103             let mut buffer = Vec::with_capacity(cap);
 104             buffer.set_len(cap);
 105             inner.initializer().initialize(&mut buffer);
 106             BufReader {
 107                 inner,
 108                 buf: buffer.into_boxed_slice(),
 109                 pos: 0,
 110                 cap: 0,
 111             }
 112         }
 113     }
 114
 115     /// Gets a reference to the underlying reader.
 116     ///
 117     /// It is inadvisable to directly read from the underlying reader.
 118     ///
 119     /// # Examples
 120     ///
 121     /// ```no_run
 122     /// use std::io::BufReader;
 123     /// use std::fs::File;
 124     ///
 125     /// fn main() -> std::io::Result<()> {
 126     ///     let f1 = File::open("log.txt")?;
 127     ///     let reader = BufReader::new(f1);
 128     ///
 129     ///     let f2 = reader.get_ref();
 130     ///     Ok(())
 131     /// }
 132     /// ```
 133     #[stable(feature = "rust1", since = "1.0.0")]
 134     pub fn get_ref(&self) -> &R { &self.inner }
 135
 136     /// Gets a mutable reference to the underlying reader.
 137     ///
 138     /// It is inadvisable to directly read from the underlying reader.
 139     ///
 140     /// # Examples
 141     ///
 142     /// ```no_run
 143     /// use std::io::BufReader;
 144     /// use std::fs::File;
 145     ///
 146     /// fn main() -> std::io::Result<()> {
 147     ///     let f1 = File::open("log.txt")?;
 148     ///     let mut reader = BufReader::new(f1);
 149     ///
 150     ///     let f2 = reader.get_mut();
 151     ///     Ok(())
 152     /// }
 153     /// ```
 154     #[stable(feature = "rust1", since = "1.0.0")]
 155     pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
 156
 157     /// Returns a reference to the internally buffered data.
 158     ///
 159     /// Unlike `fill_buf`, this will not attempt to fill the buffer if it is empty.
 160     ///
 161     /// # Examples
 162     ///
 163     /// ```no_run
 164     /// # #![feature(bufreader_buffer)]
 165     /// use std::io::{BufReader, BufRead};
 166     /// use std::fs::File;
 167     ///
 168     /// fn main() -> std::io::Result<()> {
 169     ///     let f = File::open("log.txt")?;
 170     ///     let mut reader = BufReader::new(f);
 171     ///     assert!(reader.buffer().is_empty());
 172     ///
 173     ///     if reader.fill_buf()?.len() > 0 {
 174     ///         assert!(!reader.buffer().is_empty());
 175     ///     }
 176     ///     Ok(())
 177     /// }
 178     /// ```
 179     #[unstable(feature = "bufreader_buffer", issue = "45323")]
 180     pub fn buffer(&self) -> &[u8] {
 181         &self.buf[self.pos..self.cap]
 182     }
 183
 184     /// Unwraps this `BufReader`, returning the underlying reader.
 185     ///
 186     /// Note that any leftover data in the internal buffer is lost.
 187     ///
 188     /// # Examples
 189     ///
 190     /// ```no_run
 191     /// use std::io::BufReader;
 192     /// use std::fs::File;
 193     ///
 194     /// fn main() -> std::io::Result<()> {
 195     ///     let f1 = File::open("log.txt")?;
 196     ///     let reader = BufReader::new(f1);
 197     ///
 198     ///     let f2 = reader.into_inner();
 199     ///     Ok(())
 200     /// }
 201     /// ```
 202     #[stable(feature = "rust1", since = "1.0.0")]
 203     pub fn into_inner(self) -> R { self.inner }
 204 }
 205
 206 impl<R: Seek> BufReader<R> {
 207     /// Seeks relative to the current position. If the new position lies within the buffer,
 208     /// the buffer will not be flushed, allowing for more efficient seeks.
 209     /// This method does not return the location of the underlying reader, so the caller
 210     /// must track this information themselves if it is required.
 211     #[unstable(feature = "bufreader_seek_relative", issue = "31100")]
 212     pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {
 213         let pos = self.pos as u64;
 214         if offset < 0 {
 215             if let Some(new_pos) = pos.checked_sub((-offset) as u64) {
 216                 self.pos = new_pos as usize;
 217                 return Ok(())
 218             }
 219         } else {
 220             if let Some(new_pos) = pos.checked_add(offset as u64) {
 221                 if new_pos <= self.cap as u64 {
 222                     self.pos = new_pos as usize;
 223                     return Ok(())
 224                 }
 225             }
 226         }
 227         self.seek(SeekFrom::Current(offset)).map(|_|())
 228     }
 229 }
 230
 231 #[stable(feature = "rust1", since = "1.0.0")]
 232 impl<R: Read> Read for BufReader<R> {
 233     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 234         // If we don't have any buffered data and we're doing a massive read
 235         // (larger than our internal buffer), bypass our internal buffer
 236         // entirely.
 237         if self.pos == self.cap && buf.len() >= self.buf.len() {
 238             return self.inner.read(buf);
 239         }
 240         let nread = {
 241             let mut rem = self.fill_buf()?;
 242             rem.read(buf)?
 243         };
 244         self.consume(nread);
 245         Ok(nread)
 246     }
 247
 248     // we can't skip unconditionally because of the large buffer case in read.
 249     unsafe fn initializer(&self) -> Initializer {
 250         self.inner.initializer()
 251     }
 252 }
 253
 254 #[stable(feature = "rust1", since = "1.0.0")]
 255 impl<R: Read> BufRead for BufReader<R> {
 256     fn fill_buf(&mut self) -> io::Result<&[u8]> {
 257         // If we've reached the end of our internal buffer then we need to fetch
 258         // some more data from the underlying reader.
 259         // Branch using `>=` instead of the more correct `==`
 260         // to tell the compiler that the pos..cap slice is always valid.
 261         if self.pos >= self.cap {
 262             debug_assert!(self.pos == self.cap);
 263             self.cap = self.inner.read(&mut self.buf)?;
 264             self.pos = 0;
 265         }
 266         Ok(&self.buf[self.pos..self.cap])
 267     }
 268
 269     fn consume(&mut self, amt: usize) {
 270         self.pos = cmp::min(self.pos + amt, self.cap);
 271     }
 272 }
 273
 274 #[stable(feature = "rust1", since = "1.0.0")]
 275 impl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {
 276     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 277         fmt.debug_struct("BufReader")
 278             .field("reader", &self.inner)
 279             .field("buffer", &format_args!("{}/{}", self.cap - self.pos, self.buf.len()))
 280             .finish()
 281     }
 282 }
 283
 284 #[stable(feature = "rust1", since = "1.0.0")]
 285 impl<R: Seek> Seek for BufReader<R> {
 286     /// Seek to an offset, in bytes, in the underlying reader.
 287     ///
 288     /// The position used for seeking with `SeekFrom::Current(_)` is the
 289     /// position the underlying reader would be at if the `BufReader` had no
 290     /// internal buffer.
 291     ///
 292     /// Seeking always discards the internal buffer, even if the seek position
 293     /// would otherwise fall within it. This guarantees that calling
 294     /// `.into_inner()` immediately after a seek yields the underlying reader
 295     /// at the same position.
 296     ///
 297     /// To seek without discarding the internal buffer, use [`Seek::seek_relative`].
 298     ///
 299     /// See [`std::io::Seek`] for more details.
 300     ///
 301     /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
 302     /// where `n` minus the internal buffer length overflows an `i64`, two
 303     /// seeks will be performed instead of one. If the second seek returns
 304     /// `Err`, the underlying reader will be left at the same position it would
 305     /// have if you called `seek` with `SeekFrom::Current(0)`.
 306     fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
 307         let result: u64;
 308         if let SeekFrom::Current(n) = pos {
 309             let remainder = (self.cap - self.pos) as i64;
 310             // it should be safe to assume that remainder fits within an i64 as the alternative
 311             // means we managed to allocate 8 exbibytes and that's absurd.
 312             // But it's not out of the realm of possibility for some weird underlying reader to
 313             // support seeking by i64::min_value() so we need to handle underflow when subtracting
 314             // remainder.
 315             if let Some(offset) = n.checked_sub(remainder) {
 316                 result = self.inner.seek(SeekFrom::Current(offset))?;
 317             } else {
 318                 // seek backwards by our remainder, and then by the offset
 319                 self.inner.seek(SeekFrom::Current(-remainder))?;
 320                 self.pos = self.cap; // empty the buffer
 321                 result = self.inner.seek(SeekFrom::Current(n))?;
 322             }
 323         } else {
 324             // Seeking with Start/End doesn't care about our buffer length.
 325             result = self.inner.seek(pos)?;
 326         }
 327         self.pos = self.cap; // empty the buffer
 328         Ok(result)
 329     }
 330 }
 331
 332 /// Wraps a writer and buffers its output.
 333 ///
 334 /// It can be excessively inefficient to work directly with something that
 335 /// implements [`Write`]. For example, every call to
 336 /// [`write`][`Tcpstream::write`] on [`TcpStream`] results in a system call. A
 337 /// `BufWriter` keeps an in-memory buffer of data and writes it to an underlying
 338 /// writer in large, infrequent batches.
 339 ///
 340 /// `BufWriter` can improve the speed of programs that make *small* and
 341 /// *repeated* write calls to the same file or network socket.  It does not
 342 /// help when writing very large amounts at once, or writing just one or a few
 343 /// times.  It also provides no advantage when writing to a destination that is
 344 /// in memory, like a `Vec<u8>`.
 345 ///
 346 /// When the `BufWriter` is dropped, the contents of its buffer will be written
 347 /// out. However, any errors that happen in the process of flushing the buffer
 348 /// when the writer is dropped will be ignored. Code that wishes to handle such
 349 /// errors must manually call [`flush`] before the writer is dropped.
 350 ///
 351 /// # Examples
 352 ///
 353 /// Let's write the numbers one through ten to a [`TcpStream`]:
 354 ///
 355 /// ```no_run
 356 /// use std::io::prelude::*;
 357 /// use std::net::TcpStream;
 358 ///
 359 /// let mut stream = TcpStream::connect("127.0.0.1:34254").unwrap();
 360 ///
 361 /// for i in 0..10 {
 362 ///     stream.write(&[i+1]).unwrap();
 363 /// }
 364 /// ```
 365 ///
 366 /// Because we're not buffering, we write each one in turn, incurring the
 367 /// overhead of a system call per byte written. We can fix this with a
 368 /// `BufWriter`:
 369 ///
 370 /// ```no_run
 371 /// use std::io::prelude::*;
 372 /// use std::io::BufWriter;
 373 /// use std::net::TcpStream;
 374 ///
 375 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 376 ///
 377 /// for i in 0..10 {
 378 ///     stream.write(&[i+1]).unwrap();
 379 /// }
 380 /// ```
 381 ///
 382 /// By wrapping the stream with a `BufWriter`, these ten writes are all grouped
 383 /// together by the buffer, and will all be written out in one system call when
 384 /// the `stream` is dropped.
 385 ///
 386 /// [`Write`]: ../../std/io/trait.Write.html
 387 /// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write
 388 /// [`TcpStream`]: ../../std/net/struct.TcpStream.html
 389 /// [`flush`]: #method.flush
 390 #[stable(feature = "rust1", since = "1.0.0")]
 391 pub struct BufWriter<W: Write> {
 392     inner: Option<W>,
 393     buf: Vec<u8>,
 394     // #30888: If the inner writer panics in a call to write, we don't want to
 395     // write the buffered data a second time in BufWriter's destructor. This
 396     // flag tells the Drop impl if it should skip the flush.
 397     panicked: bool,
 398 }
 399
 400 /// An error returned by `into_inner` which combines an error that
 401 /// happened while writing out the buffer, and the buffered writer object
 402 /// which may be used to recover from the condition.
 403 ///
 404 /// # Examples
 405 ///
 406 /// ```no_run
 407 /// use std::io::BufWriter;
 408 /// use std::net::TcpStream;
 409 ///
 410 /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 411 ///
 412 /// // do stuff with the stream
 413 ///
 414 /// // we want to get our `TcpStream` back, so let's try:
 415 ///
 416 /// let stream = match stream.into_inner() {
 417 ///     Ok(s) => s,
 418 ///     Err(e) => {
 419 ///         // Here, e is an IntoInnerError
 420 ///         panic!("An error occurred");
 421 ///     }
 422 /// };
 423 /// ```
 424 #[derive(Debug)]
 425 #[stable(feature = "rust1", since = "1.0.0")]
 426 pub struct IntoInnerError<W>(W, Error);
 427
 428 impl<W: Write> BufWriter<W> {
 429     /// Creates a new `BufWriter` with a default buffer capacity. The default is currently 8 KB,
 430     /// but may change in the future.
 431     ///
 432     /// # Examples
 433     ///
 434     /// ```no_run
 435     /// use std::io::BufWriter;
 436     /// use std::net::TcpStream;
 437     ///
 438     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 439     /// ```
 440     #[stable(feature = "rust1", since = "1.0.0")]
 441     pub fn new(inner: W) -> BufWriter<W> {
 442         BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)
 443     }
 444
 445     /// Creates a new `BufWriter` with the specified buffer capacity.
 446     ///
 447     /// # Examples
 448     ///
 449     /// Creating a buffer with a buffer of a hundred bytes.
 450     ///
 451     /// ```no_run
 452     /// use std::io::BufWriter;
 453     /// use std::net::TcpStream;
 454     ///
 455     /// let stream = TcpStream::connect("127.0.0.1:34254").unwrap();
 456     /// let mut buffer = BufWriter::with_capacity(100, stream);
 457     /// ```
 458     #[stable(feature = "rust1", since = "1.0.0")]
 459     pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {
 460         BufWriter {
 461             inner: Some(inner),
 462             buf: Vec::with_capacity(cap),
 463             panicked: false,
 464         }
 465     }
 466
 467     fn flush_buf(&mut self) -> io::Result<()> {
 468         let mut written = 0;
 469         let len = self.buf.len();
 470         let mut ret = Ok(());
 471         while written < len {
 472             self.panicked = true;
 473             let r = self.inner.as_mut().unwrap().write(&self.buf[written..]);
 474             self.panicked = false;
 475
 476             match r {
 477                 Ok(0) => {
 478                     ret = Err(Error::new(ErrorKind::WriteZero,
 479                                          "failed to write the buffered data"));
 480                     break;
 481                 }
 482                 Ok(n) => written += n,
 483                 Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}
 484                 Err(e) => { ret = Err(e); break }
 485
 486             }
 487         }
 488         if written > 0 {
 489             self.buf.drain(..written);
 490         }
 491         ret
 492     }
 493
 494     /// Gets a reference to the underlying writer.
 495     ///
 496     /// # Examples
 497     ///
 498     /// ```no_run
 499     /// use std::io::BufWriter;
 500     /// use std::net::TcpStream;
 501     ///
 502     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 503     ///
 504     /// // we can use reference just like buffer
 505     /// let reference = buffer.get_ref();
 506     /// ```
 507     #[stable(feature = "rust1", since = "1.0.0")]
 508     pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
 509
 510     /// Gets a mutable reference to the underlying writer.
 511     ///
 512     /// It is inadvisable to directly write to the underlying writer.
 513     ///
 514     /// # Examples
 515     ///
 516     /// ```no_run
 517     /// use std::io::BufWriter;
 518     /// use std::net::TcpStream;
 519     ///
 520     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 521     ///
 522     /// // we can use reference just like buffer
 523     /// let reference = buffer.get_mut();
 524     /// ```
 525     #[stable(feature = "rust1", since = "1.0.0")]
 526     pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
 527
 528     /// Returns a reference to the internally buffered data.
 529     ///
 530     /// # Examples
 531     ///
 532     /// ```no_run
 533     /// # #![feature(bufreader_buffer)]
 534     /// use std::io::BufWriter;
 535     /// use std::net::TcpStream;
 536     ///
 537     /// let mut buf_writer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 538     ///
 539     /// // See how many bytes are currently buffered
 540     /// let bytes_buffered = buf_writer.buffer().len();
 541     /// ```
 542     #[unstable(feature = "bufreader_buffer", issue = "45323")]
 543     pub fn buffer(&self) -> &[u8] {
 544         &self.buf[..]
 545     }
 546
 547     /// Unwraps this `BufWriter`, returning the underlying writer.
 548     ///
 549     /// The buffer is written out before returning the writer.
 550     ///
 551     /// # Errors
 552     ///
 553     /// An `Err` will be returned if an error occurs while flushing the buffer.
 554     ///
 555     /// # Examples
 556     ///
 557     /// ```no_run
 558     /// use std::io::BufWriter;
 559     /// use std::net::TcpStream;
 560     ///
 561     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 562     ///
 563     /// // unwrap the TcpStream and flush the buffer
 564     /// let stream = buffer.into_inner().unwrap();
 565     /// ```
 566     #[stable(feature = "rust1", since = "1.0.0")]
 567     pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
 568         match self.flush_buf() {
 569             Err(e) => Err(IntoInnerError(self, e)),
 570             Ok(()) => Ok(self.inner.take().unwrap())
 571         }
 572     }
 573 }
 574
 575 #[stable(feature = "rust1", since = "1.0.0")]
 576 impl<W: Write> Write for BufWriter<W> {
 577     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 578         if self.buf.len() + buf.len() > self.buf.capacity() {
 579             self.flush_buf()?;
 580         }
 581         if buf.len() >= self.buf.capacity() {
 582             self.panicked = true;
 583             let r = self.inner.as_mut().unwrap().write(buf);
 584             self.panicked = false;
 585             r
 586         } else {
 587             Write::write(&mut self.buf, buf)
 588         }
 589     }
 590     fn flush(&mut self) -> io::Result<()> {
 591         self.flush_buf().and_then(|()| self.get_mut().flush())
 592     }
 593 }
 594
 595 #[stable(feature = "rust1", since = "1.0.0")]
 596 impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
 597     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 598         fmt.debug_struct("BufWriter")
 599             .field("writer", &self.inner.as_ref().unwrap())
 600             .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
 601             .finish()
 602     }
 603 }
 604
 605 #[stable(feature = "rust1", since = "1.0.0")]
 606 impl<W: Write + Seek> Seek for BufWriter<W> {
 607     /// Seek to the offset, in bytes, in the underlying writer.
 608     ///
 609     /// Seeking always writes out the internal buffer before seeking.
 610     fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
 611         self.flush_buf().and_then(|_| self.get_mut().seek(pos))
 612     }
 613 }
 614
 615 #[stable(feature = "rust1", since = "1.0.0")]
 616 impl<W: Write> Drop for BufWriter<W> {
 617     fn drop(&mut self) {
 618         if self.inner.is_some() && !self.panicked {
 619             // dtors should not panic, so we ignore a failed flush
 620             let _r = self.flush_buf();
 621         }
 622     }
 623 }
 624
 625 impl<W> IntoInnerError<W> {
 626     /// Returns the error which caused the call to `into_inner()` to fail.
 627     ///
 628     /// This error was returned when attempting to write the internal buffer.
 629     ///
 630     /// # Examples
 631     ///
 632     /// ```no_run
 633     /// use std::io::BufWriter;
 634     /// use std::net::TcpStream;
 635     ///
 636     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 637     ///
 638     /// // do stuff with the stream
 639     ///
 640     /// // we want to get our `TcpStream` back, so let's try:
 641     ///
 642     /// let stream = match stream.into_inner() {
 643     ///     Ok(s) => s,
 644     ///     Err(e) => {
 645     ///         // Here, e is an IntoInnerError, let's log the inner error.
 646     ///         //
 647     ///         // We'll just 'log' to stdout for this example.
 648     ///         println!("{}", e.error());
 649     ///
 650     ///         panic!("An unexpected error occurred.");
 651     ///     }
 652     /// };
 653     /// ```
 654     #[stable(feature = "rust1", since = "1.0.0")]
 655     pub fn error(&self) -> &Error { &self.1 }
 656
 657     /// Returns the buffered writer instance which generated the error.
 658     ///
 659     /// The returned object can be used for error recovery, such as
 660     /// re-inspecting the buffer.
 661     ///
 662     /// # Examples
 663     ///
 664     /// ```no_run
 665     /// use std::io::BufWriter;
 666     /// use std::net::TcpStream;
 667     ///
 668     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 669     ///
 670     /// // do stuff with the stream
 671     ///
 672     /// // we want to get our `TcpStream` back, so let's try:
 673     ///
 674     /// let stream = match stream.into_inner() {
 675     ///     Ok(s) => s,
 676     ///     Err(e) => {
 677     ///         // Here, e is an IntoInnerError, let's re-examine the buffer:
 678     ///         let buffer = e.into_inner();
 679     ///
 680     ///         // do stuff to try to recover
 681     ///
 682     ///         // afterwards, let's just return the stream
 683     ///         buffer.into_inner().unwrap()
 684     ///     }
 685     /// };
 686     /// ```
 687     #[stable(feature = "rust1", since = "1.0.0")]
 688     pub fn into_inner(self) -> W { self.0 }
 689 }
 690
 691 #[stable(feature = "rust1", since = "1.0.0")]
 692 impl<W> From<IntoInnerError<W>> for Error {
 693     fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
 694 }
 695
 696 #[stable(feature = "rust1", since = "1.0.0")]
 697 impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
 698     fn description(&self) -> &str {
 699         error::Error::description(self.error())
 700     }
 701 }
 702
 703 #[stable(feature = "rust1", since = "1.0.0")]
 704 impl<W> fmt::Display for IntoInnerError<W> {
 705     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 706         self.error().fmt(f)
 707     }
 708 }
 709
 710 /// Wraps a writer and buffers output to it, flushing whenever a newline
 711 /// (`0x0a`, `'\n'`) is detected.
 712 ///
 713 /// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.
 714 /// But it only does this batched write when it goes out of scope, or when the
 715 /// internal buffer is full. Sometimes, you'd prefer to write each line as it's
 716 /// completed, rather than the entire buffer at once. Enter `LineWriter`. It
 717 /// does exactly that.
 718 ///
 719 /// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the
 720 /// `LineWriter` goes out of scope or when its internal buffer is full.
 721 ///
 722 /// [bufwriter]: struct.BufWriter.html
 723 ///
 724 /// If there's still a partial line in the buffer when the `LineWriter` is
 725 /// dropped, it will flush those contents.
 726 ///
 727 /// # Examples
 728 ///
 729 /// We can use `LineWriter` to write one line at a time, significantly
 730 /// reducing the number of actual writes to the file.
 731 ///
 732 /// ```no_run
 733 /// use std::fs::{self, File};
 734 /// use std::io::prelude::*;
 735 /// use std::io::LineWriter;
 736 ///
 737 /// fn main() -> std::io::Result<()> {
 738 ///     let road_not_taken = b"I shall be telling this with a sigh
 739 /// Somewhere ages and ages hence:
 740 /// Two roads diverged in a wood, and I -
 741 /// I took the one less traveled by,
 742 /// And that has made all the difference.";
 743 ///
 744 ///     let file = File::create("poem.txt")?;
 745 ///     let mut file = LineWriter::new(file);
 746 ///
 747 ///     file.write_all(b"I shall be telling this with a sigh")?;
 748 ///
 749 ///     // No bytes are written until a newline is encountered (or
 750 ///     // the internal buffer is filled).
 751 ///     assert_eq!(fs::read_to_string("poem.txt")?, "");
 752 ///     file.write_all(b"\n")?;
 753 ///     assert_eq!(
 754 ///         fs::read_to_string("poem.txt")?,
 755 ///         "I shall be telling this with a sigh\n",
 756 ///     );
 757 ///
 758 ///     // Write the rest of the poem.
 759 ///     file.write_all(b"Somewhere ages and ages hence:
 760 /// Two roads diverged in a wood, and I -
 761 /// I took the one less traveled by,
 762 /// And that has made all the difference.")?;
 763 ///
 764 ///     // The last line of the poem doesn't end in a newline, so
 765 ///     // we have to flush or drop the `LineWriter` to finish
 766 ///     // writing.
 767 ///     file.flush()?;
 768 ///
 769 ///     // Confirm the whole poem was written.
 770 ///     assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);
 771 ///     Ok(())
 772 /// }
 773 /// ```
 774 #[stable(feature = "rust1", since = "1.0.0")]
 775 pub struct LineWriter<W: Write> {
 776     inner: BufWriter<W>,
 777     need_flush: bool,
 778 }
 779
 780 impl<W: Write> LineWriter<W> {
 781     /// Creates a new `LineWriter`.
 782     ///
 783     /// # Examples
 784     ///
 785     /// ```no_run
 786     /// use std::fs::File;
 787     /// use std::io::LineWriter;
 788     ///
 789     /// fn main() -> std::io::Result<()> {
 790     ///     let file = File::create("poem.txt")?;
 791     ///     let file = LineWriter::new(file);
 792     ///     Ok(())
 793     /// }
 794     /// ```
 795     #[stable(feature = "rust1", since = "1.0.0")]
 796     pub fn new(inner: W) -> LineWriter<W> {
 797         // Lines typically aren't that long, don't use a giant buffer
 798         LineWriter::with_capacity(1024, inner)
 799     }
 800
 801     /// Creates a new `LineWriter` with a specified capacity for the internal
 802     /// buffer.
 803     ///
 804     /// # Examples
 805     ///
 806     /// ```no_run
 807     /// use std::fs::File;
 808     /// use std::io::LineWriter;
 809     ///
 810     /// fn main() -> std::io::Result<()> {
 811     ///     let file = File::create("poem.txt")?;
 812     ///     let file = LineWriter::with_capacity(100, file);
 813     ///     Ok(())
 814     /// }
 815     /// ```
 816     #[stable(feature = "rust1", since = "1.0.0")]
 817     pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
 818         LineWriter {
 819             inner: BufWriter::with_capacity(cap, inner),
 820             need_flush: false,
 821         }
 822     }
 823
 824     /// Gets a reference to the underlying writer.
 825     ///
 826     /// # Examples
 827     ///
 828     /// ```no_run
 829     /// use std::fs::File;
 830     /// use std::io::LineWriter;
 831     ///
 832     /// fn main() -> std::io::Result<()> {
 833     ///     let file = File::create("poem.txt")?;
 834     ///     let file = LineWriter::new(file);
 835     ///
 836     ///     let reference = file.get_ref();
 837     ///     Ok(())
 838     /// }
 839     /// ```
 840     #[stable(feature = "rust1", since = "1.0.0")]
 841     pub fn get_ref(&self) -> &W { self.inner.get_ref() }
 842
 843     /// Gets a mutable reference to the underlying writer.
 844     ///
 845     /// Caution must be taken when calling methods on the mutable reference
 846     /// returned as extra writes could corrupt the output stream.
 847     ///
 848     /// # Examples
 849     ///
 850     /// ```no_run
 851     /// use std::fs::File;
 852     /// use std::io::LineWriter;
 853     ///
 854     /// fn main() -> std::io::Result<()> {
 855     ///     let file = File::create("poem.txt")?;
 856     ///     let mut file = LineWriter::new(file);
 857     ///
 858     ///     // we can use reference just like file
 859     ///     let reference = file.get_mut();
 860     ///     Ok(())
 861     /// }
 862     /// ```
 863     #[stable(feature = "rust1", since = "1.0.0")]
 864     pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
 865
 866     /// Unwraps this `LineWriter`, returning the underlying writer.
 867     ///
 868     /// The internal buffer is written out before returning the writer.
 869     ///
 870     /// # Errors
 871     ///
 872     /// An `Err` will be returned if an error occurs while flushing the buffer.
 873     ///
 874     /// # Examples
 875     ///
 876     /// ```no_run
 877     /// use std::fs::File;
 878     /// use std::io::LineWriter;
 879     ///
 880     /// fn main() -> std::io::Result<()> {
 881     ///     let file = File::create("poem.txt")?;
 882     ///
 883     ///     let writer: LineWriter<File> = LineWriter::new(file);
 884     ///
 885     ///     let file: File = writer.into_inner()?;
 886     ///     Ok(())
 887     /// }
 888     /// ```
 889     #[stable(feature = "rust1", since = "1.0.0")]
 890     pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
 891         self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
 892             IntoInnerError(LineWriter {
 893                 inner: buf,
 894                 need_flush: false,
 895             }, e)
 896         })
 897     }
 898 }
 899
 900 #[stable(feature = "rust1", since = "1.0.0")]
 901 impl<W: Write> Write for LineWriter<W> {
 902     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 903         if self.need_flush {
 904             self.flush()?;
 905         }
 906
 907         // Find the last newline character in the buffer provided. If found then
 908         // we're going to write all the data up to that point and then flush,
 909         // otherwise we just write the whole block to the underlying writer.
 910         let i = match memchr::memrchr(b'\n', buf) {
 911             Some(i) => i,
 912             None => return self.inner.write(buf),
 913         };
 914
 915
 916         // Ok, we're going to write a partial amount of the data given first
 917         // followed by flushing the newline. After we've successfully written
 918         // some data then we *must* report that we wrote that data, so future
 919         // errors are ignored. We set our internal `need_flush` flag, though, in
 920         // case flushing fails and we need to try it first next time.
 921         let n = self.inner.write(&buf[..i + 1])?;
 922         self.need_flush = true;
 923         if self.flush().is_err() || n != i + 1 {
 924             return Ok(n)
 925         }
 926
 927         // At this point we successfully wrote `i + 1` bytes and flushed it out,
 928         // meaning that the entire line is now flushed out on the screen. While
 929         // we can attempt to finish writing the rest of the data provided.
 930         // Remember though that we ignore errors here as we've successfully
 931         // written data, so we need to report that.
 932         match self.inner.write(&buf[i + 1..]) {
 933             Ok(i) => Ok(n + i),
 934             Err(_) => Ok(n),
 935         }
 936     }
 937
 938     fn flush(&mut self) -> io::Result<()> {
 939         self.inner.flush()?;
 940         self.need_flush = false;
 941         Ok(())
 942     }
 943 }
 944
 945 #[stable(feature = "rust1", since = "1.0.0")]
 946 impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
 947     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 948         fmt.debug_struct("LineWriter")
 949             .field("writer", &self.inner.inner)
 950             .field("buffer",
 951                    &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
 952             .finish()
 953     }
 954 }
 955
 956 #[cfg(test)]
 957 mod tests {
 958     use io::prelude::*;
 959     use io::{self, BufReader, BufWriter, LineWriter, SeekFrom};
 960     use sync::atomic::{AtomicUsize, Ordering};
 961     use thread;
 962     use test;
 963
 964     /// A dummy reader intended at testing short-reads propagation.
 965     pub struct ShortReader {
 966         lengths: Vec<usize>,
 967     }
 968
 969     impl Read for ShortReader {
 970         fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
 971             if self.lengths.is_empty() {
 972                 Ok(0)
 973             } else {
 974                 Ok(self.lengths.remove(0))
 975             }
 976         }
 977     }
 978
 979     #[test]
 980     fn test_buffered_reader() {
 981         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
 982         let mut reader = BufReader::with_capacity(2, inner);
 983
 984         let mut buf = [0, 0, 0];
 985         let nread = reader.read(&mut buf);
 986         assert_eq!(nread.unwrap(), 3);
 987         let b: &[_] = &[5, 6, 7];
 988         assert_eq!(buf, b);
 989
 990         let mut buf = [0, 0];
 991         let nread = reader.read(&mut buf);
 992         assert_eq!(nread.unwrap(), 2);
 993         let b: &[_] = &[0, 1];
 994         assert_eq!(buf, b);
 995
 996         let mut buf = [0];
 997         let nread = reader.read(&mut buf);
 998         assert_eq!(nread.unwrap(), 1);
 999         let b: &[_] = &[2];
1000         assert_eq!(buf, b);
1001
1002         let mut buf = [0, 0, 0];
1003         let nread = reader.read(&mut buf);
1004         assert_eq!(nread.unwrap(), 1);
1005         let b: &[_] = &[3, 0, 0];
1006         assert_eq!(buf, b);
1007
1008         let nread = reader.read(&mut buf);
1009         assert_eq!(nread.unwrap(), 1);
1010         let b: &[_] = &[4, 0, 0];
1011         assert_eq!(buf, b);
1012
1013         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1014     }
1015
1016     #[test]
1017     fn test_buffered_reader_seek() {
1018         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1019         let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1020
1021         assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));
1022         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1023         assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));
1024         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1025         assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));
1026         assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));
1027         reader.consume(1);
1028         assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));
1029     }
1030
1031     #[test]
1032     fn test_buffered_reader_seek_relative() {
1033         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1034         let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1035
1036         assert!(reader.seek_relative(3).is_ok());
1037         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1038         assert!(reader.seek_relative(0).is_ok());
1039         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1040         assert!(reader.seek_relative(1).is_ok());
1041         assert_eq!(reader.fill_buf().ok(), Some(&[1][..]));
1042         assert!(reader.seek_relative(-1).is_ok());
1043         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1044         assert!(reader.seek_relative(2).is_ok());
1045         assert_eq!(reader.fill_buf().ok(), Some(&[2, 3][..]));
1046     }
1047
1048     #[test]
1049     fn test_buffered_reader_seek_underflow() {
1050         // gimmick reader that yields its position modulo 256 for each byte
1051         struct PositionReader {
1052             pos: u64
1053         }
1054         impl Read for PositionReader {
1055             fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1056                 let len = buf.len();
1057                 for x in buf {
1058                     *x = self.pos as u8;
1059                     self.pos = self.pos.wrapping_add(1);
1060                 }
1061                 Ok(len)
1062             }
1063         }
1064         impl Seek for PositionReader {
1065             fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
1066                 match pos {
1067                     SeekFrom::Start(n) => {
1068                         self.pos = n;
1069                     }
1070                     SeekFrom::Current(n) => {
1071                         self.pos = self.pos.wrapping_add(n as u64);
1072                     }
1073                     SeekFrom::End(n) => {
1074                         self.pos = u64::max_value().wrapping_add(n as u64);
1075                     }
1076                 }
1077                 Ok(self.pos)
1078             }
1079         }
1080
1081         let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
1082         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
1083         assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));
1084         assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1085         // the following seek will require two underlying seeks
1086         let expected = 9223372036854775802;
1087         assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));
1088         assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1089         // seeking to 0 should empty the buffer.
1090         assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));
1091         assert_eq!(reader.get_ref().pos, expected);
1092     }
1093
1094     #[test]
1095     fn test_buffered_writer() {
1096         let inner = Vec::new();
1097         let mut writer = BufWriter::with_capacity(2, inner);
1098
1099         writer.write(&[0, 1]).unwrap();
1100         assert_eq!(*writer.get_ref(), [0, 1]);
1101
1102         writer.write(&[2]).unwrap();
1103         assert_eq!(*writer.get_ref(), [0, 1]);
1104
1105         writer.write(&[3]).unwrap();
1106         assert_eq!(*writer.get_ref(), [0, 1]);
1107
1108         writer.flush().unwrap();
1109         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1110
1111         writer.write(&[4]).unwrap();
1112         writer.write(&[5]).unwrap();
1113         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1114
1115         writer.write(&[6]).unwrap();
1116         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
1117
1118         writer.write(&[7, 8]).unwrap();
1119         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
1120
1121         writer.write(&[9, 10, 11]).unwrap();
1122         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1123
1124         writer.flush().unwrap();
1125         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1126     }
1127
1128     #[test]
1129     fn test_buffered_writer_inner_flushes() {
1130         let mut w = BufWriter::with_capacity(3, Vec::new());
1131         w.write(&[0, 1]).unwrap();
1132         assert_eq!(*w.get_ref(), []);
1133         let w = w.into_inner().unwrap();
1134         assert_eq!(w, [0, 1]);
1135     }
1136
1137     #[test]
1138     fn test_buffered_writer_seek() {
1139         let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));
1140         w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
1141         w.write_all(&[6, 7]).unwrap();
1142         assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));
1143         assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
1144         assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));
1145         w.write_all(&[8, 9]).unwrap();
1146         assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
1147     }
1148
1149     #[test]
1150     fn test_read_until() {
1151         let inner: &[u8] = &[0, 1, 2, 1, 0];
1152         let mut reader = BufReader::with_capacity(2, inner);
1153         let mut v = Vec::new();
1154         reader.read_until(0, &mut v).unwrap();
1155         assert_eq!(v, [0]);
1156         v.truncate(0);
1157         reader.read_until(2, &mut v).unwrap();
1158         assert_eq!(v, [1, 2]);
1159         v.truncate(0);
1160         reader.read_until(1, &mut v).unwrap();
1161         assert_eq!(v, [1]);
1162         v.truncate(0);
1163         reader.read_until(8, &mut v).unwrap();
1164         assert_eq!(v, [0]);
1165         v.truncate(0);
1166         reader.read_until(9, &mut v).unwrap();
1167         assert_eq!(v, []);
1168     }
1169
1170     #[test]
1171     fn test_line_buffer_fail_flush() {
1172         // Issue #32085
1173         struct FailFlushWriter<'a>(&'a mut Vec<u8>);
1174
1175         impl<'a> Write for FailFlushWriter<'a> {
1176             fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
1177                 self.0.extend_from_slice(buf);
1178                 Ok(buf.len())
1179             }
1180             fn flush(&mut self) -> io::Result<()> {
1181                 Err(io::Error::new(io::ErrorKind::Other, "flush failed"))
1182             }
1183         }
1184
1185         let mut buf = Vec::new();
1186         {
1187             let mut writer = LineWriter::new(FailFlushWriter(&mut buf));
1188             let to_write = b"abc\ndef";
1189             if let Ok(written) = writer.write(to_write) {
1190                 assert!(written < to_write.len(), "didn't flush on new line");
1191                 // PASS
1192                 return;
1193             }
1194         }
1195         assert!(buf.is_empty(), "write returned an error but wrote data");
1196     }
1197
1198     #[test]
1199     fn test_line_buffer() {
1200         let mut writer = LineWriter::new(Vec::new());
1201         writer.write(&[0]).unwrap();
1202         assert_eq!(*writer.get_ref(), []);
1203         writer.write(&[1]).unwrap();
1204         assert_eq!(*writer.get_ref(), []);
1205         writer.flush().unwrap();
1206         assert_eq!(*writer.get_ref(), [0, 1]);
1207         writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
1208         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
1209         writer.flush().unwrap();
1210         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
1211         writer.write(&[3, b'\n']).unwrap();
1212         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
1213     }
1214
1215     #[test]
1216     fn test_read_line() {
1217         let in_buf: &[u8] = b"a\nb\nc";
1218         let mut reader = BufReader::with_capacity(2, in_buf);
1219         let mut s = String::new();
1220         reader.read_line(&mut s).unwrap();
1221         assert_eq!(s, "a\n");
1222         s.truncate(0);
1223         reader.read_line(&mut s).unwrap();
1224         assert_eq!(s, "b\n");
1225         s.truncate(0);
1226         reader.read_line(&mut s).unwrap();
1227         assert_eq!(s, "c");
1228         s.truncate(0);
1229         reader.read_line(&mut s).unwrap();
1230         assert_eq!(s, "");
1231     }
1232
1233     #[test]
1234     fn test_lines() {
1235         let in_buf: &[u8] = b"a\nb\nc";
1236         let reader = BufReader::with_capacity(2, in_buf);
1237         let mut it = reader.lines();
1238         assert_eq!(it.next().unwrap().unwrap(), "a".to_string());
1239         assert_eq!(it.next().unwrap().unwrap(), "b".to_string());
1240         assert_eq!(it.next().unwrap().unwrap(), "c".to_string());
1241         assert!(it.next().is_none());
1242     }
1243
1244     #[test]
1245     fn test_short_reads() {
1246         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
1247         let mut reader = BufReader::new(inner);
1248         let mut buf = [0, 0];
1249         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1250         assert_eq!(reader.read(&mut buf).unwrap(), 1);
1251         assert_eq!(reader.read(&mut buf).unwrap(), 2);
1252         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1253         assert_eq!(reader.read(&mut buf).unwrap(), 1);
1254         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1255         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1256     }
1257
1258     #[test]
1259     #[should_panic]
1260     fn dont_panic_in_drop_on_panicked_flush() {
1261         struct FailFlushWriter;
1262
1263         impl Write for FailFlushWriter {
1264             fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
1265             fn flush(&mut self) -> io::Result<()> {
1266                 Err(io::Error::last_os_error())
1267             }
1268         }
1269
1270         let writer = FailFlushWriter;
1271         let _writer = BufWriter::new(writer);
1272
1273         // If writer panics *again* due to the flush error then the process will
1274         // abort.
1275         panic!();
1276     }
1277
1278     #[test]
1279     #[cfg_attr(target_os = "emscripten", ignore)]
1280     fn panic_in_write_doesnt_flush_in_drop() {
1281         static WRITES: AtomicUsize = AtomicUsize::new(0);
1282
1283         struct PanicWriter;
1284
1285         impl Write for PanicWriter {
1286             fn write(&mut self, _: &[u8]) -> io::Result<usize> {
1287                 WRITES.fetch_add(1, Ordering::SeqCst);
1288                 panic!();
1289             }
1290             fn flush(&mut self) -> io::Result<()> { Ok(()) }
1291         }
1292
1293         thread::spawn(|| {
1294             let mut writer = BufWriter::new(PanicWriter);
1295             let _ = writer.write(b"hello world");
1296             let _ = writer.flush();
1297         }).join().unwrap_err();
1298
1299         assert_eq!(WRITES.load(Ordering::SeqCst), 1);
1300     }
1301
1302     #[bench]
1303     fn bench_buffered_reader(b: &mut test::Bencher) {
1304         b.iter(|| {
1305             BufReader::new(io::empty())
1306         });
1307     }
1308
1309     #[bench]
1310     fn bench_buffered_writer(b: &mut test::Bencher) {
1311         b.iter(|| {
1312             BufWriter::new(io::sink())
1313         });
1314     }
1315
1316     struct AcceptOneThenFail {
1317         written: bool,
1318         flushed: bool,
1319     }
1320
1321     impl Write for AcceptOneThenFail {
1322         fn write(&mut self, data: &[u8]) -> io::Result<usize> {
1323             if !self.written {
1324                 assert_eq!(data, b"a\nb\n");
1325                 self.written = true;
1326                 Ok(data.len())
1327             } else {
1328                 Err(io::Error::new(io::ErrorKind::NotFound, "test"))
1329             }
1330         }
1331
1332         fn flush(&mut self) -> io::Result<()> {
1333             assert!(self.written);
1334             assert!(!self.flushed);
1335             self.flushed = true;
1336             Err(io::Error::new(io::ErrorKind::Other, "test"))
1337         }
1338     }
1339
1340     #[test]
1341     fn erroneous_flush_retried() {
1342         let a = AcceptOneThenFail {
1343             written: false,
1344             flushed: false,
1345         };
1346
1347         let mut l = LineWriter::new(a);
1348         assert_eq!(l.write(b"a\nb\na").unwrap(), 4);
1349         assert!(l.get_ref().written);
1350         assert!(l.get_ref().flushed);
1351         l.get_mut().flushed = false;
1352
1353         assert_eq!(l.write(b"a").unwrap_err().kind(), io::ErrorKind::Other)
1354     }
1355 }