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.
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.
11 //! Buffering wrappers for I/O traits
20 use io
::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom}
;
24 /// Wraps a `Read` and buffers input from it
26 /// It can be excessively inefficient to work directly with a `Read` instance.
27 /// For example, every call to `read` on `TcpStream` results in a system call.
28 /// A `BufReader` performs large, infrequent reads on the underlying `Read`
29 /// and maintains an in-memory buffer of the results.
34 /// use std::io::prelude::*;
35 /// use std::io::BufReader;
36 /// use std::fs::File;
38 /// # fn foo() -> std::io::Result<()> {
39 /// let mut f = try!(File::open("log.txt"));
40 /// let mut reader = BufReader::new(f);
42 /// let mut line = String::new();
43 /// let len = try!(reader.read_line(&mut line));
44 /// println!("First line is {} bytes long", len);
48 #[stable(feature = "rust1", since = "1.0.0")]
49 pub struct BufReader
<R
> {
56 impl<R
: Read
> BufReader
<R
> {
57 /// Creates a new `BufReader` with a default buffer capacity
58 #[stable(feature = "rust1", since = "1.0.0")]
59 pub fn new(inner
: R
) -> BufReader
<R
> {
60 BufReader
::with_capacity(DEFAULT_BUF_SIZE
, inner
)
63 /// Creates a new `BufReader` with the specified buffer capacity
64 #[stable(feature = "rust1", since = "1.0.0")]
65 pub fn with_capacity(cap
: usize, inner
: R
) -> BufReader
<R
> {
66 let mut buf
= Vec
::with_capacity(cap
);
67 buf
.extend(iter
::repeat(0).take(cap
));
76 /// Gets a reference to the underlying reader.
77 #[stable(feature = "rust1", since = "1.0.0")]
78 pub fn get_ref(&self) -> &R { &self.inner }
80 /// Gets a mutable reference to the underlying reader.
84 /// It is inadvisable to directly read from the underlying reader.
85 #[stable(feature = "rust1", since = "1.0.0")]
86 pub fn get_mut(&mut self) -> &mut R { &mut self.inner }
88 /// Unwraps this `BufReader`, returning the underlying reader.
90 /// Note that any leftover data in the internal buffer is lost.
91 #[stable(feature = "rust1", since = "1.0.0")]
92 pub fn into_inner(self) -> R { self.inner }
95 #[stable(feature = "rust1", since = "1.0.0")]
96 impl<R
: Read
> Read
for BufReader
<R
> {
97 fn read(&mut self, buf
: &mut [u8]) -> io
::Result
<usize> {
98 // If we don't have any buffered data and we're doing a massive read
99 // (larger than our internal buffer), bypass our internal buffer
101 if self.pos
== self.cap
&& buf
.len() >= self.buf
.len() {
102 return self.inner
.read(buf
);
105 let mut rem
= try
!(self.fill_buf());
113 #[stable(feature = "rust1", since = "1.0.0")]
114 impl<R
: Read
> BufRead
for BufReader
<R
> {
115 fn fill_buf(&mut self) -> io
::Result
<&[u8]> {
116 // If we've reached the end of our internal buffer then we need to fetch
117 // some more data from the underlying reader.
118 if self.pos
== self.cap
{
119 self.cap
= try
!(self.inner
.read(&mut self.buf
));
122 Ok(&self.buf
[self.pos
..self.cap
])
125 fn consume(&mut self, amt
: usize) {
126 self.pos
= cmp
::min(self.pos
+ amt
, self.cap
);
130 #[stable(feature = "rust1", since = "1.0.0")]
131 impl<R
> fmt
::Debug
for BufReader
<R
> where R
: fmt
::Debug
{
132 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
133 fmt
.debug_struct("BufReader")
134 .field("reader", &self.inner
)
135 .field("buffer", &format_args
!("{}/{}", self.cap
- self.pos
, self.buf
.len()))
140 #[stable(feature = "rust1", since = "1.0.0")]
141 impl<R
: Seek
> Seek
for BufReader
<R
> {
142 /// Seek to an offset, in bytes, in the underlying reader.
144 /// The position used for seeking with `SeekFrom::Current(_)` is the
145 /// position the underlying reader would be at if the `BufReader` had no
148 /// Seeking always discards the internal buffer, even if the seek position
149 /// would otherwise fall within it. This guarantees that calling
150 /// `.unwrap()` immediately after a seek yields the underlying reader at
151 /// the same position.
153 /// See `std::io::Seek` for more details.
155 /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`
156 /// where `n` minus the internal buffer length underflows an `i64`, two
157 /// seeks will be performed instead of one. If the second seek returns
158 /// `Err`, the underlying reader will be left at the same position it would
159 /// have if you seeked to `SeekFrom::Current(0)`.
160 fn seek(&mut self, pos
: SeekFrom
) -> io
::Result
<u64> {
162 if let SeekFrom
::Current(n
) = pos
{
163 let remainder
= (self.cap
- self.pos
) as i64;
164 // it should be safe to assume that remainder fits within an i64 as the alternative
165 // means we managed to allocate 8 ebibytes and that's absurd.
166 // But it's not out of the realm of possibility for some weird underlying reader to
167 // support seeking by i64::min_value() so we need to handle underflow when subtracting
169 if let Some(offset
) = n
.checked_sub(remainder
) {
170 result
= try
!(self.inner
.seek(SeekFrom
::Current(offset
)));
172 // seek backwards by our remainder, and then by the offset
173 try
!(self.inner
.seek(SeekFrom
::Current(-remainder
)));
174 self.pos
= self.cap
; // empty the buffer
175 result
= try
!(self.inner
.seek(SeekFrom
::Current(n
)));
178 // Seeking with Start/End doesn't care about our buffer length.
179 result
= try
!(self.inner
.seek(pos
));
181 self.pos
= self.cap
; // empty the buffer
186 /// Wraps a Writer and buffers output to it
188 /// It can be excessively inefficient to work directly with a `Write`. For
189 /// example, every call to `write` on `TcpStream` results in a system call. A
190 /// `BufWriter` keeps an in memory buffer of data and writes it to the
191 /// underlying `Write` in large, infrequent batches.
193 /// The buffer will be written out when the writer is dropped.
194 #[stable(feature = "rust1", since = "1.0.0")]
195 pub struct BufWriter
<W
: Write
> {
200 /// An error returned by `into_inner` which combines an error that
201 /// happened while writing out the buffer, and the buffered writer object
202 /// which may be used to recover from the condition.
204 #[stable(feature = "rust1", since = "1.0.0")]
205 pub struct IntoInnerError
<W
>(W
, Error
);
207 impl<W
: Write
> BufWriter
<W
> {
208 /// Creates a new `BufWriter` with a default buffer capacity
209 #[stable(feature = "rust1", since = "1.0.0")]
210 pub fn new(inner
: W
) -> BufWriter
<W
> {
211 BufWriter
::with_capacity(DEFAULT_BUF_SIZE
, inner
)
214 /// Creates a new `BufWriter` with the specified buffer capacity
215 #[stable(feature = "rust1", since = "1.0.0")]
216 pub fn with_capacity(cap
: usize, inner
: W
) -> BufWriter
<W
> {
219 buf
: Vec
::with_capacity(cap
),
223 fn flush_buf(&mut self) -> io
::Result
<()> {
225 let len
= self.buf
.len();
226 let mut ret
= Ok(());
227 while written
< len
{
228 match self.inner
.as_mut().unwrap().write(&self.buf
[written
..]) {
230 ret
= Err(Error
::new(ErrorKind
::WriteZero
,
231 "failed to write the buffered data"));
234 Ok(n
) => written
+= n
,
235 Err(ref e
) if e
.kind() == io
::ErrorKind
::Interrupted
=> {}
236 Err(e
) => { ret = Err(e); break }
241 // NB: would be better expressed as .remove(0..n) if it existed
243 ptr
::copy(self.buf
.as_ptr().offset(written
as isize),
244 self.buf
.as_mut_ptr(),
248 self.buf
.truncate(len
- written
);
252 /// Gets a reference to the underlying writer.
253 #[stable(feature = "rust1", since = "1.0.0")]
254 pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }
256 /// Gets a mutable reference to the underlying write.
260 /// It is inadvisable to directly read from the underlying writer.
261 #[stable(feature = "rust1", since = "1.0.0")]
262 pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }
264 /// Unwraps this `BufWriter`, returning the underlying writer.
266 /// The buffer is written out before returning the writer.
267 #[stable(feature = "rust1", since = "1.0.0")]
268 pub fn into_inner(mut self) -> Result
<W
, IntoInnerError
<BufWriter
<W
>>> {
269 match self.flush_buf() {
270 Err(e
) => Err(IntoInnerError(self, e
)),
271 Ok(()) => Ok(self.inner
.take().unwrap())
276 #[stable(feature = "rust1", since = "1.0.0")]
277 impl<W
: Write
> Write
for BufWriter
<W
> {
278 fn write(&mut self, buf
: &[u8]) -> io
::Result
<usize> {
279 if self.buf
.len() + buf
.len() > self.buf
.capacity() {
280 try
!(self.flush_buf());
282 if buf
.len() >= self.buf
.capacity() {
283 self.inner
.as_mut().unwrap().write(buf
)
285 let amt
= cmp
::min(buf
.len(), self.buf
.capacity());
286 Write
::write(&mut self.buf
, &buf
[..amt
])
289 fn flush(&mut self) -> io
::Result
<()> {
290 self.flush_buf().and_then(|()| self.get_mut().flush())
294 #[stable(feature = "rust1", since = "1.0.0")]
295 impl<W
: Write
> fmt
::Debug
for BufWriter
<W
> where W
: fmt
::Debug
{
296 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
297 fmt
.debug_struct("BufWriter")
298 .field("writer", &self.inner
.as_ref().unwrap())
299 .field("buffer", &format_args
!("{}/{}", self.buf
.len(), self.buf
.capacity()))
304 #[stable(feature = "rust1", since = "1.0.0")]
305 impl<W
: Write
+ Seek
> Seek
for BufWriter
<W
> {
306 /// Seek to the offset, in bytes, in the underlying writer.
308 /// Seeking always writes out the internal buffer before seeking.
309 fn seek(&mut self, pos
: SeekFrom
) -> io
::Result
<u64> {
310 self.flush_buf().and_then(|_
| self.get_mut().seek(pos
))
314 impl<W
: Write
> Drop
for BufWriter
<W
> {
316 if self.inner
.is_some() {
317 // dtors should not panic, so we ignore a failed flush
318 let _r
= self.flush_buf();
323 impl<W
> IntoInnerError
<W
> {
324 /// Returns the error which caused the call to `into_inner` to fail.
326 /// This error was returned when attempting to write the internal buffer.
327 #[stable(feature = "rust1", since = "1.0.0")]
328 pub fn error(&self) -> &Error { &self.1 }
330 /// Returns the buffered writer instance which generated the error.
332 /// The returned object can be used for error recovery, such as
333 /// re-inspecting the buffer.
334 #[stable(feature = "rust1", since = "1.0.0")]
335 pub fn into_inner(self) -> W { self.0 }
338 #[stable(feature = "rust1", since = "1.0.0")]
339 impl<W
> From
<IntoInnerError
<W
>> for Error
{
340 fn from(iie
: IntoInnerError
<W
>) -> Error { iie.1 }
343 #[stable(feature = "rust1", since = "1.0.0")]
344 impl<W
: Reflect
+ Send
+ fmt
::Debug
> error
::Error
for IntoInnerError
<W
> {
345 fn description(&self) -> &str {
346 error
::Error
::description(self.error())
350 #[stable(feature = "rust1", since = "1.0.0")]
351 impl<W
> fmt
::Display
for IntoInnerError
<W
> {
352 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
357 /// Wraps a Writer and buffers output to it, flushing whenever a newline
358 /// (`0x0a`, `'\n'`) is detected.
360 /// The buffer will be written out when the writer is dropped.
361 #[stable(feature = "rust1", since = "1.0.0")]
362 pub struct LineWriter
<W
: Write
> {
366 impl<W
: Write
> LineWriter
<W
> {
367 /// Creates a new `LineWriter`
368 #[stable(feature = "rust1", since = "1.0.0")]
369 pub fn new(inner
: W
) -> LineWriter
<W
> {
370 // Lines typically aren't that long, don't use a giant buffer
371 LineWriter
::with_capacity(1024, inner
)
374 /// Creates a new `LineWriter` with a specified capacity for the internal
376 #[stable(feature = "rust1", since = "1.0.0")]
377 pub fn with_capacity(cap
: usize, inner
: W
) -> LineWriter
<W
> {
378 LineWriter { inner: BufWriter::with_capacity(cap, inner) }
381 /// Gets a reference to the underlying writer.
382 #[stable(feature = "rust1", since = "1.0.0")]
383 pub fn get_ref(&self) -> &W { self.inner.get_ref() }
385 /// Gets a mutable reference to the underlying writer.
387 /// Caution must be taken when calling methods on the mutable reference
388 /// returned as extra writes could corrupt the output stream.
389 #[stable(feature = "rust1", since = "1.0.0")]
390 pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }
392 /// Unwraps this `LineWriter`, returning the underlying writer.
394 /// The internal buffer is written out before returning the writer.
395 #[stable(feature = "rust1", since = "1.0.0")]
396 pub fn into_inner(self) -> Result
<W
, IntoInnerError
<LineWriter
<W
>>> {
397 self.inner
.into_inner().map_err(|IntoInnerError(buf
, e
)| {
398 IntoInnerError(LineWriter { inner: buf }
, e
)
403 #[stable(feature = "rust1", since = "1.0.0")]
404 impl<W
: Write
> Write
for LineWriter
<W
> {
405 fn write(&mut self, buf
: &[u8]) -> io
::Result
<usize> {
406 match buf
.rposition_elem(&b'
\n'
) {
408 let n
= try
!(self.inner
.write(&buf
[..i
+ 1]));
409 if n
!= i
+ 1 { return Ok(n) }
410 try
!(self.inner
.flush());
411 self.inner
.write(&buf
[i
+ 1..]).map(|i
| n
+ i
)
413 None
=> self.inner
.write(buf
),
417 fn flush(&mut self) -> io
::Result
<()> { self.inner.flush() }
420 #[stable(feature = "rust1", since = "1.0.0")]
421 impl<W
: Write
> fmt
::Debug
for LineWriter
<W
> where W
: fmt
::Debug
{
422 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
423 fmt
.debug_struct("LineWriter")
424 .field("writer", &self.inner
.inner
)
426 &format_args
!("{}/{}", self.inner
.buf
.len(), self.inner
.buf
.capacity()))
431 struct InternalBufWriter
<W
: Write
>(BufWriter
<W
>);
433 impl<W
: Read
+ Write
> InternalBufWriter
<W
> {
434 fn get_mut(&mut self) -> &mut BufWriter
<W
> {
435 let InternalBufWriter(ref mut w
) = *self;
440 impl<W
: Read
+ Write
> Read
for InternalBufWriter
<W
> {
441 fn read(&mut self, buf
: &mut [u8]) -> io
::Result
<usize> {
442 self.get_mut().inner
.as_mut().unwrap().read(buf
)
446 /// Wraps a Stream and buffers input and output to and from it.
448 /// It can be excessively inefficient to work directly with a `Read+Write`. For
449 /// example, every call to `read` or `write` on `TcpStream` results in a system
450 /// call. A `BufStream` keeps in memory buffers of data, making large,
451 /// infrequent calls to `read` and `write` on the underlying `Read+Write`.
453 /// The output buffer will be written out when this stream is dropped.
454 #[unstable(feature = "buf_stream",
455 reason
= "unsure about semantics of buffering two directions, \
456 leading to issues like #17136")]
457 #[deprecated(since = "1.2.0",
458 reason
= "use the crates.io `bufstream` crate instead")]
459 pub struct BufStream
<S
: Write
> {
460 inner
: BufReader
<InternalBufWriter
<S
>>
463 #[unstable(feature = "buf_stream",
464 reason
= "unsure about semantics of buffering two directions, \
465 leading to issues like #17136")]
466 #[deprecated(since = "1.2.0",
467 reason
= "use the crates.io `bufstream` crate instead")]
469 impl<S
: Read
+ Write
> BufStream
<S
> {
470 /// Creates a new buffered stream with explicitly listed capacities for the
471 /// reader/writer buffer.
472 pub fn with_capacities(reader_cap
: usize, writer_cap
: usize, inner
: S
)
474 let writer
= BufWriter
::with_capacity(writer_cap
, inner
);
475 let internal_writer
= InternalBufWriter(writer
);
476 let reader
= BufReader
::with_capacity(reader_cap
, internal_writer
);
477 BufStream { inner: reader }
480 /// Creates a new buffered stream with the default reader/writer buffer
482 pub fn new(inner
: S
) -> BufStream
<S
> {
483 BufStream
::with_capacities(DEFAULT_BUF_SIZE
, DEFAULT_BUF_SIZE
, inner
)
486 /// Gets a reference to the underlying stream.
487 pub fn get_ref(&self) -> &S
{
488 let InternalBufWriter(ref w
) = self.inner
.inner
;
492 /// Gets a mutable reference to the underlying stream.
496 /// It is inadvisable to read directly from or write directly to the
497 /// underlying stream.
498 pub fn get_mut(&mut self) -> &mut S
{
499 let InternalBufWriter(ref mut w
) = self.inner
.inner
;
503 /// Unwraps this `BufStream`, returning the underlying stream.
505 /// The internal write buffer is written out before returning the stream.
506 /// Any leftover data in the read buffer is lost.
507 pub fn into_inner(self) -> Result
<S
, IntoInnerError
<BufStream
<S
>>> {
508 let BufReader { inner: InternalBufWriter(w), buf, pos, cap }
= self.inner
;
509 w
.into_inner().map_err(|IntoInnerError(w
, e
)| {
510 IntoInnerError(BufStream
{
511 inner
: BufReader { inner: InternalBufWriter(w), buf: buf, pos: pos, cap: cap }
,
517 #[unstable(feature = "buf_stream",
518 reason
= "unsure about semantics of buffering two directions, \
519 leading to issues like #17136")]
521 impl<S
: Read
+ Write
> BufRead
for BufStream
<S
> {
522 fn fill_buf(&mut self) -> io
::Result
<&[u8]> { self.inner.fill_buf() }
523 fn consume(&mut self, amt
: usize) { self.inner.consume(amt) }
526 #[unstable(feature = "buf_stream",
527 reason
= "unsure about semantics of buffering two directions, \
528 leading to issues like #17136")]
530 impl<S
: Read
+ Write
> Read
for BufStream
<S
> {
531 fn read(&mut self, buf
: &mut [u8]) -> io
::Result
<usize> {
536 #[unstable(feature = "buf_stream",
537 reason
= "unsure about semantics of buffering two directions, \
538 leading to issues like #17136")]
540 impl<S
: Read
+ Write
> Write
for BufStream
<S
> {
541 fn write(&mut self, buf
: &[u8]) -> io
::Result
<usize> {
542 self.inner
.inner
.get_mut().write(buf
)
544 fn flush(&mut self) -> io
::Result
<()> {
545 self.inner
.inner
.get_mut().flush()
549 #[unstable(feature = "buf_stream",
550 reason
= "unsure about semantics of buffering two directions, \
551 leading to issues like #17136")]
553 impl<S
: Write
> fmt
::Debug
for BufStream
<S
> where S
: fmt
::Debug
{
554 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
555 let reader
= &self.inner
;
556 let writer
= &self.inner
.inner
.0;
557 fmt
.debug_struct("BufStream")
558 .field("stream", &writer
.inner
)
559 .field("write_buffer", &format_args
!("{}/{}", writer
.buf
.len(), writer
.buf
.capacity()))
560 .field("read_buffer",
561 &format_args
!("{}/{}", reader
.cap
- reader
.pos
, reader
.buf
.len()))
570 use io
::{self, BufReader, BufWriter, BufStream, Cursor, LineWriter, SeekFrom}
;
573 /// A dummy reader intended at testing short-reads propagation.
574 pub struct ShortReader
{
578 impl Read
for ShortReader
{
579 fn read(&mut self, _
: &mut [u8]) -> io
::Result
<usize> {
580 if self.lengths
.is_empty() {
583 Ok(self.lengths
.remove(0))
589 fn test_buffered_reader() {
590 let inner
: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
591 let mut reader
= BufReader
::with_capacity(2, inner
);
593 let mut buf
= [0, 0, 0];
594 let nread
= reader
.read(&mut buf
);
595 assert_eq
!(nread
.unwrap(), 3);
596 let b
: &[_
] = &[5, 6, 7];
599 let mut buf
= [0, 0];
600 let nread
= reader
.read(&mut buf
);
601 assert_eq
!(nread
.unwrap(), 2);
602 let b
: &[_
] = &[0, 1];
606 let nread
= reader
.read(&mut buf
);
607 assert_eq
!(nread
.unwrap(), 1);
611 let mut buf
= [0, 0, 0];
612 let nread
= reader
.read(&mut buf
);
613 assert_eq
!(nread
.unwrap(), 1);
614 let b
: &[_
] = &[3, 0, 0];
617 let nread
= reader
.read(&mut buf
);
618 assert_eq
!(nread
.unwrap(), 1);
619 let b
: &[_
] = &[4, 0, 0];
622 assert_eq
!(reader
.read(&mut buf
).unwrap(), 0);
626 fn test_buffered_reader_seek() {
627 let inner
: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];
628 let mut reader
= BufReader
::with_capacity(2, io
::Cursor
::new(inner
));
630 assert_eq
!(reader
.seek(SeekFrom
::Start(3)).ok(), Some(3));
631 assert_eq
!(reader
.fill_buf().ok(), Some(&[0, 1][..]));
632 assert_eq
!(reader
.seek(SeekFrom
::Current(0)).ok(), Some(3));
633 assert_eq
!(reader
.fill_buf().ok(), Some(&[0, 1][..]));
634 assert_eq
!(reader
.seek(SeekFrom
::Current(1)).ok(), Some(4));
635 assert_eq
!(reader
.fill_buf().ok(), Some(&[1, 2][..]));
637 assert_eq
!(reader
.seek(SeekFrom
::Current(-2)).ok(), Some(3));
641 fn test_buffered_reader_seek_underflow() {
642 // gimmick reader that yields its position modulo 256 for each byte
643 struct PositionReader
{
646 impl Read
for PositionReader
{
647 fn read(&mut self, buf
: &mut [u8]) -> io
::Result
<usize> {
651 self.pos
= self.pos
.wrapping_add(1);
656 impl Seek
for PositionReader
{
657 fn seek(&mut self, pos
: SeekFrom
) -> io
::Result
<u64> {
659 SeekFrom
::Start(n
) => {
662 SeekFrom
::Current(n
) => {
663 self.pos
= self.pos
.wrapping_add(n
as u64);
665 SeekFrom
::End(n
) => {
666 self.pos
= u64::max_value().wrapping_add(n
as u64);
673 let mut reader
= BufReader
::with_capacity(5, PositionReader { pos: 0 }
);
674 assert_eq
!(reader
.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
675 assert_eq
!(reader
.seek(SeekFrom
::End(-5)).ok(), Some(u64::max_value()-5));
676 assert_eq
!(reader
.fill_buf().ok().map(|s
| s
.len()), Some(5));
677 // the following seek will require two underlying seeks
678 let expected
= 9223372036854775802;
679 assert_eq
!(reader
.seek(SeekFrom
::Current(i64::min_value())).ok(), Some(expected
));
680 assert_eq
!(reader
.fill_buf().ok().map(|s
| s
.len()), Some(5));
681 // seeking to 0 should empty the buffer.
682 assert_eq
!(reader
.seek(SeekFrom
::Current(0)).ok(), Some(expected
));
683 assert_eq
!(reader
.get_ref().pos
, expected
);
687 fn test_buffered_writer() {
688 let inner
= Vec
::new();
689 let mut writer
= BufWriter
::with_capacity(2, inner
);
691 writer
.write(&[0, 1]).unwrap();
692 assert_eq
!(*writer
.get_ref(), [0, 1]);
694 writer
.write(&[2]).unwrap();
695 assert_eq
!(*writer
.get_ref(), [0, 1]);
697 writer
.write(&[3]).unwrap();
698 assert_eq
!(*writer
.get_ref(), [0, 1]);
700 writer
.flush().unwrap();
701 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3]);
703 writer
.write(&[4]).unwrap();
704 writer
.write(&[5]).unwrap();
705 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3]);
707 writer
.write(&[6]).unwrap();
708 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3, 4, 5]);
710 writer
.write(&[7, 8]).unwrap();
711 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
713 writer
.write(&[9, 10, 11]).unwrap();
714 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
716 writer
.flush().unwrap();
717 assert_eq
!(*writer
.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
721 fn test_buffered_writer_inner_flushes() {
722 let mut w
= BufWriter
::with_capacity(3, Vec
::new());
723 w
.write(&[0, 1]).unwrap();
724 assert_eq
!(*w
.get_ref(), []);
725 let w
= w
.into_inner().unwrap();
726 assert_eq
!(w
, [0, 1]);
730 fn test_buffered_writer_seek() {
731 let mut w
= BufWriter
::with_capacity(3, io
::Cursor
::new(Vec
::new()));
732 w
.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();
733 w
.write_all(&[6, 7]).unwrap();
734 assert_eq
!(w
.seek(SeekFrom
::Current(0)).ok(), Some(8));
735 assert_eq
!(&w
.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);
736 assert_eq
!(w
.seek(SeekFrom
::Start(2)).ok(), Some(2));
737 w
.write_all(&[8, 9]).unwrap();
738 assert_eq
!(&w
.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);
741 // This is just here to make sure that we don't infinite loop in the
742 // newtype struct autoderef weirdness
744 fn test_buffered_stream() {
748 fn write(&mut self, b
: &[u8]) -> io
::Result
<usize> { Ok(b.len()) }
749 fn flush(&mut self) -> io
::Result
<()> { Ok(()) }
753 fn read(&mut self, _
: &mut [u8]) -> io
::Result
<usize> { Ok(0) }
756 let mut stream
= BufStream
::new(S
);
757 assert_eq
!(stream
.read(&mut [0; 10]).unwrap(), 0);
758 stream
.write(&[0; 10]).unwrap();
759 stream
.flush().unwrap();
763 fn test_read_until() {
764 let inner
: &[u8] = &[0, 1, 2, 1, 0];
765 let mut reader
= BufReader
::with_capacity(2, inner
);
766 let mut v
= Vec
::new();
767 reader
.read_until(0, &mut v
).unwrap();
770 reader
.read_until(2, &mut v
).unwrap();
771 assert_eq
!(v
, [1, 2]);
773 reader
.read_until(1, &mut v
).unwrap();
776 reader
.read_until(8, &mut v
).unwrap();
779 reader
.read_until(9, &mut v
).unwrap();
784 fn test_line_buffer() {
785 let mut writer
= LineWriter
::new(Vec
::new());
786 writer
.write(&[0]).unwrap();
787 assert_eq
!(*writer
.get_ref(), []);
788 writer
.write(&[1]).unwrap();
789 assert_eq
!(*writer
.get_ref(), []);
790 writer
.flush().unwrap();
791 assert_eq
!(*writer
.get_ref(), [0, 1]);
792 writer
.write(&[0, b'
\n'
, 1, b'
\n'
, 2]).unwrap();
793 assert_eq
!(*writer
.get_ref(), [0, 1, 0, b'
\n'
, 1, b'
\n'
]);
794 writer
.flush().unwrap();
795 assert_eq
!(*writer
.get_ref(), [0, 1, 0, b'
\n'
, 1, b'
\n'
, 2]);
796 writer
.write(&[3, b'
\n'
]).unwrap();
797 assert_eq
!(*writer
.get_ref(), [0, 1, 0, b'
\n'
, 1, b'
\n'
, 2, 3, b'
\n'
]);
801 fn test_read_line() {
802 let in_buf
: &[u8] = b
"a\nb\nc";
803 let mut reader
= BufReader
::with_capacity(2, in_buf
);
804 let mut s
= String
::new();
805 reader
.read_line(&mut s
).unwrap();
806 assert_eq
!(s
, "a\n");
808 reader
.read_line(&mut s
).unwrap();
809 assert_eq
!(s
, "b\n");
811 reader
.read_line(&mut s
).unwrap();
814 reader
.read_line(&mut s
).unwrap();
820 let in_buf
: &[u8] = b
"a\nb\nc";
821 let reader
= BufReader
::with_capacity(2, in_buf
);
822 let mut it
= reader
.lines();
823 assert_eq
!(it
.next().unwrap().unwrap(), "a".to_string());
824 assert_eq
!(it
.next().unwrap().unwrap(), "b".to_string());
825 assert_eq
!(it
.next().unwrap().unwrap(), "c".to_string());
826 assert
!(it
.next().is_none());
830 fn test_short_reads() {
831 let inner
= ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]}
;
832 let mut reader
= BufReader
::new(inner
);
833 let mut buf
= [0, 0];
834 assert_eq
!(reader
.read(&mut buf
).unwrap(), 0);
835 assert_eq
!(reader
.read(&mut buf
).unwrap(), 1);
836 assert_eq
!(reader
.read(&mut buf
).unwrap(), 2);
837 assert_eq
!(reader
.read(&mut buf
).unwrap(), 0);
838 assert_eq
!(reader
.read(&mut buf
).unwrap(), 1);
839 assert_eq
!(reader
.read(&mut buf
).unwrap(), 0);
840 assert_eq
!(reader
.read(&mut buf
).unwrap(), 0);
844 fn read_char_buffered() {
845 let buf
= [195, 159];
846 let reader
= BufReader
::with_capacity(1, &buf
[..]);
847 assert_eq
!(reader
.chars().next().unwrap().unwrap(), 'ß'
);
852 let buf
= [195, 159, b'a'
];
853 let reader
= BufReader
::with_capacity(1, &buf
[..]);
854 let mut it
= reader
.chars();
855 assert_eq
!(it
.next().unwrap().unwrap(), 'ß'
);
856 assert_eq
!(it
.next().unwrap().unwrap(), 'a'
);
857 assert
!(it
.next().is_none());
862 fn dont_panic_in_drop_on_panicked_flush() {
863 struct FailFlushWriter
;
865 impl Write
for FailFlushWriter
{
866 fn write(&mut self, buf
: &[u8]) -> io
::Result
<usize> { Ok(buf.len()) }
867 fn flush(&mut self) -> io
::Result
<()> {
868 Err(io
::Error
::last_os_error())
872 let writer
= FailFlushWriter
;
873 let _writer
= BufWriter
::new(writer
);
875 // If writer panics *again* due to the flush error then the process will
881 fn bench_buffered_reader(b
: &mut test
::Bencher
) {
883 BufReader
::new(io
::empty())
888 fn bench_buffered_writer(b
: &mut test
::Bencher
) {
890 BufWriter
::new(io
::sink())
895 fn bench_buffered_stream(b
: &mut test
::Bencher
) {
896 let mut buf
= Cursor
::new(Vec
::new());
898 BufStream
::new(&mut buf
);