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     /// Unwraps this `BufWriter`, returning the underlying writer.
 529     ///
 530     /// The buffer is written out before returning the writer.
 531     ///
 532     /// # Errors
 533     ///
 534     /// An `Err` will be returned if an error occurs while flushing the buffer.
 535     ///
 536     /// # Examples
 537     ///
 538     /// ```no_run
 539     /// use std::io::BufWriter;
 540     /// use std::net::TcpStream;
 541     ///
 542     /// let mut buffer = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 543     ///
 544     /// // unwrap the TcpStream and flush the buffer
 545     /// let stream = buffer.into_inner().unwrap();
 546     /// ```
 547     #[stable(feature = "rust1", since = "1.0.0")]
 548     pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {
 549         match self.flush_buf() {
 550             Err(e) => Err(IntoInnerError(self, e)),
 551             Ok(()) => Ok(self.inner.take().unwrap())
 552         }
 553     }
 554 }
 555
 556 #[stable(feature = "rust1", since = "1.0.0")]
 557 impl<W: Write> Write for BufWriter<W> {
 558     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 559         if self.buf.len() + buf.len() > self.buf.capacity() {
 560             self.flush_buf()?;
 561         }
 562         if buf.len() >= self.buf.capacity() {
 563             self.panicked = true;
 564             let r = self.inner.as_mut().unwrap().write(buf);
 565             self.panicked = false;
 566             r
 567         } else {
 568             Write::write(&mut self.buf, buf)
 569         }
 570     }
 571     fn flush(&mut self) -> io::Result<()> {
 572         self.flush_buf().and_then(|()| self.get_mut().flush())
 573     }
 574 }
 575
 576 #[stable(feature = "rust1", since = "1.0.0")]
 577 impl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {
 578     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 579         fmt.debug_struct("BufWriter")
 580             .field("writer", &self.inner.as_ref().unwrap())
 581             .field("buffer", &format_args!("{}/{}", self.buf.len(), self.buf.capacity()))
 582             .finish()
 583     }
 584 }
 585
 586 #[stable(feature = "rust1", since = "1.0.0")]
 587 impl<W: Write + Seek> Seek for BufWriter<W> {
 588     /// Seek to the offset, in bytes, in the underlying writer.
 589     ///
 590     /// Seeking always writes out the internal buffer before seeking.
 591     fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
 592         self.flush_buf().and_then(|_| self.get_mut().seek(pos))
 593     }
 594 }
 595
 596 #[stable(feature = "rust1", since = "1.0.0")]
 597 impl<W: Write> Drop for BufWriter<W> {
 598     fn drop(&mut self) {
 599         if self.inner.is_some() && !self.panicked {
 600             // dtors should not panic, so we ignore a failed flush
 601             let _r = self.flush_buf();
 602         }
 603     }
 604 }
 605
 606 impl<W> IntoInnerError<W> {
 607     /// Returns the error which caused the call to `into_inner()` to fail.
 608     ///
 609     /// This error was returned when attempting to write the internal buffer.
 610     ///
 611     /// # Examples
 612     ///
 613     /// ```no_run
 614     /// use std::io::BufWriter;
 615     /// use std::net::TcpStream;
 616     ///
 617     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 618     ///
 619     /// // do stuff with the stream
 620     ///
 621     /// // we want to get our `TcpStream` back, so let's try:
 622     ///
 623     /// let stream = match stream.into_inner() {
 624     ///     Ok(s) => s,
 625     ///     Err(e) => {
 626     ///         // Here, e is an IntoInnerError, let's log the inner error.
 627     ///         //
 628     ///         // We'll just 'log' to stdout for this example.
 629     ///         println!("{}", e.error());
 630     ///
 631     ///         panic!("An unexpected error occurred.");
 632     ///     }
 633     /// };
 634     /// ```
 635     #[stable(feature = "rust1", since = "1.0.0")]
 636     pub fn error(&self) -> &Error { &self.1 }
 637
 638     /// Returns the buffered writer instance which generated the error.
 639     ///
 640     /// The returned object can be used for error recovery, such as
 641     /// re-inspecting the buffer.
 642     ///
 643     /// # Examples
 644     ///
 645     /// ```no_run
 646     /// use std::io::BufWriter;
 647     /// use std::net::TcpStream;
 648     ///
 649     /// let mut stream = BufWriter::new(TcpStream::connect("127.0.0.1:34254").unwrap());
 650     ///
 651     /// // do stuff with the stream
 652     ///
 653     /// // we want to get our `TcpStream` back, so let's try:
 654     ///
 655     /// let stream = match stream.into_inner() {
 656     ///     Ok(s) => s,
 657     ///     Err(e) => {
 658     ///         // Here, e is an IntoInnerError, let's re-examine the buffer:
 659     ///         let buffer = e.into_inner();
 660     ///
 661     ///         // do stuff to try to recover
 662     ///
 663     ///         // afterwards, let's just return the stream
 664     ///         buffer.into_inner().unwrap()
 665     ///     }
 666     /// };
 667     /// ```
 668     #[stable(feature = "rust1", since = "1.0.0")]
 669     pub fn into_inner(self) -> W { self.0 }
 670 }
 671
 672 #[stable(feature = "rust1", since = "1.0.0")]
 673 impl<W> From<IntoInnerError<W>> for Error {
 674     fn from(iie: IntoInnerError<W>) -> Error { iie.1 }
 675 }
 676
 677 #[stable(feature = "rust1", since = "1.0.0")]
 678 impl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {
 679     fn description(&self) -> &str {
 680         error::Error::description(self.error())
 681     }
 682 }
 683
 684 #[stable(feature = "rust1", since = "1.0.0")]
 685 impl<W> fmt::Display for IntoInnerError<W> {
 686     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 687         self.error().fmt(f)
 688     }
 689 }
 690
 691 /// Wraps a writer and buffers output to it, flushing whenever a newline
 692 /// (`0x0a`, `'\n'`) is detected.
 693 ///
 694 /// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.
 695 /// But it only does this batched write when it goes out of scope, or when the
 696 /// internal buffer is full. Sometimes, you'd prefer to write each line as it's
 697 /// completed, rather than the entire buffer at once. Enter `LineWriter`. It
 698 /// does exactly that.
 699 ///
 700 /// Like [`BufWriter`], a `LineWriter`’s buffer will also be flushed when the
 701 /// `LineWriter` goes out of scope or when its internal buffer is full.
 702 ///
 703 /// [bufwriter]: struct.BufWriter.html
 704 ///
 705 /// If there's still a partial line in the buffer when the `LineWriter` is
 706 /// dropped, it will flush those contents.
 707 ///
 708 /// # Examples
 709 ///
 710 /// We can use `LineWriter` to write one line at a time, significantly
 711 /// reducing the number of actual writes to the file.
 712 ///
 713 /// ```no_run
 714 /// use std::fs::{self, File};
 715 /// use std::io::prelude::*;
 716 /// use std::io::LineWriter;
 717 ///
 718 /// fn main() -> std::io::Result<()> {
 719 ///     let road_not_taken = b"I shall be telling this with a sigh
 720 /// Somewhere ages and ages hence:
 721 /// Two roads diverged in a wood, and I -
 722 /// I took the one less traveled by,
 723 /// And that has made all the difference.";
 724 ///
 725 ///     let file = File::create("poem.txt")?;
 726 ///     let mut file = LineWriter::new(file);
 727 ///
 728 ///     file.write_all(b"I shall be telling this with a sigh")?;
 729 ///
 730 ///     // No bytes are written until a newline is encountered (or
 731 ///     // the internal buffer is filled).
 732 ///     assert_eq!(fs::read_to_string("poem.txt")?, "");
 733 ///     file.write_all(b"\n")?;
 734 ///     assert_eq!(
 735 ///         fs::read_to_string("poem.txt")?,
 736 ///         "I shall be telling this with a sigh\n",
 737 ///     );
 738 ///
 739 ///     // Write the rest of the poem.
 740 ///     file.write_all(b"Somewhere ages and ages hence:
 741 /// Two roads diverged in a wood, and I -
 742 /// I took the one less traveled by,
 743 /// And that has made all the difference.")?;
 744 ///
 745 ///     // The last line of the poem doesn't end in a newline, so
 746 ///     // we have to flush or drop the `LineWriter` to finish
 747 ///     // writing.
 748 ///     file.flush()?;
 749 ///
 750 ///     // Confirm the whole poem was written.
 751 ///     assert_eq!(fs::read("poem.txt")?, &road_not_taken[..]);
 752 ///     Ok(())
 753 /// }
 754 /// ```
 755 #[stable(feature = "rust1", since = "1.0.0")]
 756 pub struct LineWriter<W: Write> {
 757     inner: BufWriter<W>,
 758     need_flush: bool,
 759 }
 760
 761 impl<W: Write> LineWriter<W> {
 762     /// Creates a new `LineWriter`.
 763     ///
 764     /// # Examples
 765     ///
 766     /// ```no_run
 767     /// use std::fs::File;
 768     /// use std::io::LineWriter;
 769     ///
 770     /// fn main() -> std::io::Result<()> {
 771     ///     let file = File::create("poem.txt")?;
 772     ///     let file = LineWriter::new(file);
 773     ///     Ok(())
 774     /// }
 775     /// ```
 776     #[stable(feature = "rust1", since = "1.0.0")]
 777     pub fn new(inner: W) -> LineWriter<W> {
 778         // Lines typically aren't that long, don't use a giant buffer
 779         LineWriter::with_capacity(1024, inner)
 780     }
 781
 782     /// Creates a new `LineWriter` with a specified capacity for the internal
 783     /// buffer.
 784     ///
 785     /// # Examples
 786     ///
 787     /// ```no_run
 788     /// use std::fs::File;
 789     /// use std::io::LineWriter;
 790     ///
 791     /// fn main() -> std::io::Result<()> {
 792     ///     let file = File::create("poem.txt")?;
 793     ///     let file = LineWriter::with_capacity(100, file);
 794     ///     Ok(())
 795     /// }
 796     /// ```
 797     #[stable(feature = "rust1", since = "1.0.0")]
 798     pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {
 799         LineWriter {
 800             inner: BufWriter::with_capacity(cap, inner),
 801             need_flush: false,
 802         }
 803     }
 804
 805     /// Gets a reference to the underlying writer.
 806     ///
 807     /// # Examples
 808     ///
 809     /// ```no_run
 810     /// use std::fs::File;
 811     /// use std::io::LineWriter;
 812     ///
 813     /// fn main() -> std::io::Result<()> {
 814     ///     let file = File::create("poem.txt")?;
 815     ///     let file = LineWriter::new(file);
 816     ///
 817     ///     let reference = file.get_ref();
 818     ///     Ok(())
 819     /// }
 820     /// ```
 821     #[stable(feature = "rust1", since = "1.0.0")]
 822     pub fn get_ref(&self) -> &W { self.inner.get_ref() }
 823
 824     /// Gets a mutable reference to the underlying writer.
 825     ///
 826     /// Caution must be taken when calling methods on the mutable reference
 827     /// returned as extra writes could corrupt the output stream.
 828     ///
 829     /// # Examples
 830     ///
 831     /// ```no_run
 832     /// use std::fs::File;
 833     /// use std::io::LineWriter;
 834     ///
 835     /// fn main() -> std::io::Result<()> {
 836     ///     let file = File::create("poem.txt")?;
 837     ///     let mut file = LineWriter::new(file);
 838     ///
 839     ///     // we can use reference just like file
 840     ///     let reference = file.get_mut();
 841     ///     Ok(())
 842     /// }
 843     /// ```
 844     #[stable(feature = "rust1", since = "1.0.0")]
 845     pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
 846
 847     /// Unwraps this `LineWriter`, returning the underlying writer.
 848     ///
 849     /// The internal buffer is written out before returning the writer.
 850     ///
 851     /// # Errors
 852     ///
 853     /// An `Err` will be returned if an error occurs while flushing the buffer.
 854     ///
 855     /// # Examples
 856     ///
 857     /// ```no_run
 858     /// use std::fs::File;
 859     /// use std::io::LineWriter;
 860     ///
 861     /// fn main() -> std::io::Result<()> {
 862     ///     let file = File::create("poem.txt")?;
 863     ///
 864     ///     let writer: LineWriter<File> = LineWriter::new(file);
 865     ///
 866     ///     let file: File = writer.into_inner()?;
 867     ///     Ok(())
 868     /// }
 869     /// ```
 870     #[stable(feature = "rust1", since = "1.0.0")]
 871     pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
 872         self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {
 873             IntoInnerError(LineWriter {
 874                 inner: buf,
 875                 need_flush: false,
 876             }, e)
 877         })
 878     }
 879 }
 880
 881 #[stable(feature = "rust1", since = "1.0.0")]
 882 impl<W: Write> Write for LineWriter<W> {
 883     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 884         if self.need_flush {
 885             self.flush()?;
 886         }
 887
 888         // Find the last newline character in the buffer provided. If found then
 889         // we're going to write all the data up to that point and then flush,
 890         // otherwise we just write the whole block to the underlying writer.
 891         let i = match memchr::memrchr(b'\n', buf) {
 892             Some(i) => i,
 893             None => return self.inner.write(buf),
 894         };
 895
 896
 897         // Ok, we're going to write a partial amount of the data given first
 898         // followed by flushing the newline. After we've successfully written
 899         // some data then we *must* report that we wrote that data, so future
 900         // errors are ignored. We set our internal `need_flush` flag, though, in
 901         // case flushing fails and we need to try it first next time.
 902         let n = self.inner.write(&buf[..i + 1])?;
 903         self.need_flush = true;
 904         if self.flush().is_err() || n != i + 1 {
 905             return Ok(n)
 906         }
 907
 908         // At this point we successfully wrote `i + 1` bytes and flushed it out,
 909         // meaning that the entire line is now flushed out on the screen. While
 910         // we can attempt to finish writing the rest of the data provided.
 911         // Remember though that we ignore errors here as we've successfully
 912         // written data, so we need to report that.
 913         match self.inner.write(&buf[i + 1..]) {
 914             Ok(i) => Ok(n + i),
 915             Err(_) => Ok(n),
 916         }
 917     }
 918
 919     fn flush(&mut self) -> io::Result<()> {
 920         self.inner.flush()?;
 921         self.need_flush = false;
 922         Ok(())
 923     }
 924 }
 925
 926 #[stable(feature = "rust1", since = "1.0.0")]
 927 impl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {
 928     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 929         fmt.debug_struct("LineWriter")
 930             .field("writer", &self.inner.inner)
 931             .field("buffer",
 932                    &format_args!("{}/{}", self.inner.buf.len(), self.inner.buf.capacity()))
 933             .finish()
 934     }
 935 }
 936
 937 #[cfg(test)]
 938 mod tests {
 939     use io::prelude::*;
 940     use io::{self, BufReader, BufWriter, LineWriter, SeekFrom};
 941     use sync::atomic::{AtomicUsize, Ordering};
 942     use thread;
 943     use test;
 944
 945     /// A dummy reader intended at testing short-reads propagation.
 946     pub struct ShortReader {
 947         lengths: Vec<usize>,
 948     }
 949
 950     impl Read for ShortReader {
 951         fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {
 952             if self.lengths.is_empty() {
 953                 Ok(0)
 954             } else {
 955                 Ok(self.lengths.remove(0))
 956             }
 957         }
 958     }
 959
 960     #[test]
 961     fn test_buffered_reader() {
 962         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
 963         let mut reader = BufReader::with_capacity(2, inner);
 964
 965         let mut buf = [0, 0, 0];
 966         let nread = reader.read(&mut buf);
 967         assert_eq!(nread.unwrap(), 3);
 968         let b: &[_] = &[5, 6, 7];
 969         assert_eq!(buf, b);
 970
 971         let mut buf = [0, 0];
 972         let nread = reader.read(&mut buf);
 973         assert_eq!(nread.unwrap(), 2);
 974         let b: &[_] = &[0, 1];
 975         assert_eq!(buf, b);
 976
 977         let mut buf = [0];
 978         let nread = reader.read(&mut buf);
 979         assert_eq!(nread.unwrap(), 1);
 980         let b: &[_] = &[2];
 981         assert_eq!(buf, b);
 982
 983         let mut buf = [0, 0, 0];
 984         let nread = reader.read(&mut buf);
 985         assert_eq!(nread.unwrap(), 1);
 986         let b: &[_] = &[3, 0, 0];
 987         assert_eq!(buf, b);
 988
 989         let nread = reader.read(&mut buf);
 990         assert_eq!(nread.unwrap(), 1);
 991         let b: &[_] = &[4, 0, 0];
 992         assert_eq!(buf, b);
 993
 994         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 995     }
 996
 997     #[test]
 998     fn test_buffered_reader_seek() {
 999         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1000         let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1001
1002         assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));
1003         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1004         assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));
1005         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1006         assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));
1007         assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));
1008         reader.consume(1);
1009         assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));
1010     }
1011
1012     #[test]
1013     fn test_buffered_reader_seek_relative() {
1014         let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
1015         let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));
1016
1017         assert!(reader.seek_relative(3).is_ok());
1018         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1019         assert!(reader.seek_relative(0).is_ok());
1020         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1021         assert!(reader.seek_relative(1).is_ok());
1022         assert_eq!(reader.fill_buf().ok(), Some(&[1][..]));
1023         assert!(reader.seek_relative(-1).is_ok());
1024         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));
1025         assert!(reader.seek_relative(2).is_ok());
1026         assert_eq!(reader.fill_buf().ok(), Some(&[2, 3][..]));
1027     }
1028
1029     #[test]
1030     fn test_buffered_reader_seek_underflow() {
1031         // gimmick reader that yields its position modulo 256 for each byte
1032         struct PositionReader {
1033             pos: u64
1034         }
1035         impl Read for PositionReader {
1036             fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
1037                 let len = buf.len();
1038                 for x in buf {
1039                     *x = self.pos as u8;
1040                     self.pos = self.pos.wrapping_add(1);
1041                 }
1042                 Ok(len)
1043             }
1044         }
1045         impl Seek for PositionReader {
1046             fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
1047                 match pos {
1048                     SeekFrom::Start(n) => {
1049                         self.pos = n;
1050                     }
1051                     SeekFrom::Current(n) => {
1052                         self.pos = self.pos.wrapping_add(n as u64);
1053                     }
1054                     SeekFrom::End(n) => {
1055                         self.pos = u64::max_value().wrapping_add(n as u64);
1056                     }
1057                 }
1058                 Ok(self.pos)
1059             }
1060         }
1061
1062         let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });
1063         assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
1064         assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));
1065         assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1066         // the following seek will require two underlying seeks
1067         let expected = 9223372036854775802;
1068         assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));
1069         assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
1070         // seeking to 0 should empty the buffer.
1071         assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));
1072         assert_eq!(reader.get_ref().pos, expected);
1073     }
1074
1075     #[test]
1076     fn test_buffered_writer() {
1077         let inner = Vec::new();
1078         let mut writer = BufWriter::with_capacity(2, inner);
1079
1080         writer.write(&[0, 1]).unwrap();
1081         assert_eq!(*writer.get_ref(), [0, 1]);
1082
1083         writer.write(&[2]).unwrap();
1084         assert_eq!(*writer.get_ref(), [0, 1]);
1085
1086         writer.write(&[3]).unwrap();
1087         assert_eq!(*writer.get_ref(), [0, 1]);
1088
1089         writer.flush().unwrap();
1090         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1091
1092         writer.write(&[4]).unwrap();
1093         writer.write(&[5]).unwrap();
1094         assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
1095
1096         writer.write(&[6]).unwrap();
1097         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
1098
1099         writer.write(&[7, 8]).unwrap();
1100         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
1101
1102         writer.write(&[9, 10, 11]).unwrap();
1103         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1104
1105         writer.flush().unwrap();
1106         assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
1107     }
1108
1109     #[test]
1110     fn test_buffered_writer_inner_flushes() {
1111         let mut w = BufWriter::with_capacity(3, Vec::new());
1112         w.write(&[0, 1]).unwrap();
1113         assert_eq!(*w.get_ref(), []);
1114         let w = w.into_inner().unwrap();
1115         assert_eq!(w, [0, 1]);
1116     }
1117
1118     #[test]
1119     fn test_buffered_writer_seek() {
1120         let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));
1121         w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
1122         w.write_all(&[6, 7]).unwrap();
1123         assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));
1124         assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
1125         assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));
1126         w.write_all(&[8, 9]).unwrap();
1127         assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
1128     }
1129
1130     #[test]
1131     fn test_read_until() {
1132         let inner: &[u8] = &[0, 1, 2, 1, 0];
1133         let mut reader = BufReader::with_capacity(2, inner);
1134         let mut v = Vec::new();
1135         reader.read_until(0, &mut v).unwrap();
1136         assert_eq!(v, [0]);
1137         v.truncate(0);
1138         reader.read_until(2, &mut v).unwrap();
1139         assert_eq!(v, [1, 2]);
1140         v.truncate(0);
1141         reader.read_until(1, &mut v).unwrap();
1142         assert_eq!(v, [1]);
1143         v.truncate(0);
1144         reader.read_until(8, &mut v).unwrap();
1145         assert_eq!(v, [0]);
1146         v.truncate(0);
1147         reader.read_until(9, &mut v).unwrap();
1148         assert_eq!(v, []);
1149     }
1150
1151     #[test]
1152     fn test_line_buffer_fail_flush() {
1153         // Issue #32085
1154         struct FailFlushWriter<'a>(&'a mut Vec<u8>);
1155
1156         impl<'a> Write for FailFlushWriter<'a> {
1157             fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
1158                 self.0.extend_from_slice(buf);
1159                 Ok(buf.len())
1160             }
1161             fn flush(&mut self) -> io::Result<()> {
1162                 Err(io::Error::new(io::ErrorKind::Other, "flush failed"))
1163             }
1164         }
1165
1166         let mut buf = Vec::new();
1167         {
1168             let mut writer = LineWriter::new(FailFlushWriter(&mut buf));
1169             let to_write = b"abc\ndef";
1170             if let Ok(written) = writer.write(to_write) {
1171                 assert!(written < to_write.len(), "didn't flush on new line");
1172                 // PASS
1173                 return;
1174             }
1175         }
1176         assert!(buf.is_empty(), "write returned an error but wrote data");
1177     }
1178
1179     #[test]
1180     fn test_line_buffer() {
1181         let mut writer = LineWriter::new(Vec::new());
1182         writer.write(&[0]).unwrap();
1183         assert_eq!(*writer.get_ref(), []);
1184         writer.write(&[1]).unwrap();
1185         assert_eq!(*writer.get_ref(), []);
1186         writer.flush().unwrap();
1187         assert_eq!(*writer.get_ref(), [0, 1]);
1188         writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
1189         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n']);
1190         writer.flush().unwrap();
1191         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2]);
1192         writer.write(&[3, b'\n']).unwrap();
1193         assert_eq!(*writer.get_ref(), [0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n']);
1194     }
1195
1196     #[test]
1197     fn test_read_line() {
1198         let in_buf: &[u8] = b"a\nb\nc";
1199         let mut reader = BufReader::with_capacity(2, in_buf);
1200         let mut s = String::new();
1201         reader.read_line(&mut s).unwrap();
1202         assert_eq!(s, "a\n");
1203         s.truncate(0);
1204         reader.read_line(&mut s).unwrap();
1205         assert_eq!(s, "b\n");
1206         s.truncate(0);
1207         reader.read_line(&mut s).unwrap();
1208         assert_eq!(s, "c");
1209         s.truncate(0);
1210         reader.read_line(&mut s).unwrap();
1211         assert_eq!(s, "");
1212     }
1213
1214     #[test]
1215     fn test_lines() {
1216         let in_buf: &[u8] = b"a\nb\nc";
1217         let reader = BufReader::with_capacity(2, in_buf);
1218         let mut it = reader.lines();
1219         assert_eq!(it.next().unwrap().unwrap(), "a".to_string());
1220         assert_eq!(it.next().unwrap().unwrap(), "b".to_string());
1221         assert_eq!(it.next().unwrap().unwrap(), "c".to_string());
1222         assert!(it.next().is_none());
1223     }
1224
1225     #[test]
1226     fn test_short_reads() {
1227         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
1228         let mut reader = BufReader::new(inner);
1229         let mut buf = [0, 0];
1230         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1231         assert_eq!(reader.read(&mut buf).unwrap(), 1);
1232         assert_eq!(reader.read(&mut buf).unwrap(), 2);
1233         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1234         assert_eq!(reader.read(&mut buf).unwrap(), 1);
1235         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1236         assert_eq!(reader.read(&mut buf).unwrap(), 0);
1237     }
1238
1239     #[test]
1240     #[should_panic]
1241     fn dont_panic_in_drop_on_panicked_flush() {
1242         struct FailFlushWriter;
1243
1244         impl Write for FailFlushWriter {
1245             fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }
1246             fn flush(&mut self) -> io::Result<()> {
1247                 Err(io::Error::last_os_error())
1248             }
1249         }
1250
1251         let writer = FailFlushWriter;
1252         let _writer = BufWriter::new(writer);
1253
1254         // If writer panics *again* due to the flush error then the process will
1255         // abort.
1256         panic!();
1257     }
1258
1259     #[test]
1260     #[cfg_attr(target_os = "emscripten", ignore)]
1261     fn panic_in_write_doesnt_flush_in_drop() {
1262         static WRITES: AtomicUsize = AtomicUsize::new(0);
1263
1264         struct PanicWriter;
1265
1266         impl Write for PanicWriter {
1267             fn write(&mut self, _: &[u8]) -> io::Result<usize> {
1268                 WRITES.fetch_add(1, Ordering::SeqCst);
1269                 panic!();
1270             }
1271             fn flush(&mut self) -> io::Result<()> { Ok(()) }
1272         }
1273
1274         thread::spawn(|| {
1275             let mut writer = BufWriter::new(PanicWriter);
1276             let _ = writer.write(b"hello world");
1277             let _ = writer.flush();
1278         }).join().unwrap_err();
1279
1280         assert_eq!(WRITES.load(Ordering::SeqCst), 1);
1281     }
1282
1283     #[bench]
1284     fn bench_buffered_reader(b: &mut test::Bencher) {
1285         b.iter(|| {
1286             BufReader::new(io::empty())
1287         });
1288     }
1289
1290     #[bench]
1291     fn bench_buffered_writer(b: &mut test::Bencher) {
1292         b.iter(|| {
1293             BufWriter::new(io::sink())
1294         });
1295     }
1296
1297     struct AcceptOneThenFail {
1298         written: bool,
1299         flushed: bool,
1300     }
1301
1302     impl Write for AcceptOneThenFail {
1303         fn write(&mut self, data: &[u8]) -> io::Result<usize> {
1304             if !self.written {
1305                 assert_eq!(data, b"a\nb\n");
1306                 self.written = true;
1307                 Ok(data.len())
1308             } else {
1309                 Err(io::Error::new(io::ErrorKind::NotFound, "test"))
1310             }
1311         }
1312
1313         fn flush(&mut self) -> io::Result<()> {
1314             assert!(self.written);
1315             assert!(!self.flushed);
1316             self.flushed = true;
1317             Err(io::Error::new(io::ErrorKind::Other, "test"))
1318         }
1319     }
1320
1321     #[test]
1322     fn erroneous_flush_retried() {
1323         let a = AcceptOneThenFail {
1324             written: false,
1325             flushed: false,
1326         };
1327
1328         let mut l = LineWriter::new(a);
1329         assert_eq!(l.write(b"a\nb\na").unwrap(), 4);
1330         assert!(l.get_ref().written);
1331         assert!(l.get_ref().flushed);
1332         l.get_mut().flushed = false;
1333
1334         assert_eq!(l.write(b"a").unwrap_err().kind(), io::ErrorKind::Other)
1335     }
1336 }