src/libstd/old_io/mem.rs

   1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10 //
  11 // ignore-lexer-test FIXME #15679
  12
  13 //! Readers and Writers for in-memory buffers
  14
  15 use cmp::min;
  16 use option::Option::None;
  17 use result::Result::{Err, Ok};
  18 use old_io;
  19 use old_io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
  20 use slice;
  21 use vec::Vec;
  22
  23 const BUF_CAPACITY: usize = 128;
  24
  25 fn combine(seek: SeekStyle, cur: usize, end: usize, offset: i64) -> IoResult<u64> {
  26     // compute offset as signed and clamp to prevent overflow
  27     let pos = match seek {
  28         old_io::SeekSet => 0,
  29         old_io::SeekEnd => end,
  30         old_io::SeekCur => cur,
  31     } as i64;
  32
  33     if offset + pos < 0 {
  34         Err(IoError {
  35             kind: old_io::InvalidInput,
  36             desc: "invalid seek to a negative offset",
  37             detail: None
  38         })
  39     } else {
  40         Ok((offset + pos) as u64)
  41     }
  42 }
  43
  44 impl Writer for Vec<u8> {
  45     #[inline]
  46     fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
  47         self.push_all(buf);
  48         Ok(())
  49     }
  50 }
  51
  52 /// Writes to an owned, growable byte vector
  53 ///
  54 /// # Examples
  55 ///
  56 /// ```
  57 /// # #![feature(old_io, io)]
  58 /// # #![allow(unused_must_use)]
  59 /// use std::old_io::*;
  60 ///
  61 /// let mut w = MemWriter::new();
  62 /// w.write(&[0, 1, 2]);
  63 ///
  64 /// assert_eq!(w.into_inner(), [0, 1, 2]);
  65 /// ```
  66 #[unstable(feature = "io")]
  67 #[deprecated(since = "1.0.0",
  68              reason = "use the Vec<u8> Writer implementation directly")]
  69 #[derive(Clone)]
  70 #[allow(deprecated)]
  71 pub struct MemWriter {
  72     buf: Vec<u8>,
  73 }
  74
  75 #[allow(deprecated)]
  76 impl MemWriter {
  77     /// Create a new `MemWriter`.
  78     #[inline]
  79     pub fn new() -> MemWriter {
  80         MemWriter::with_capacity(BUF_CAPACITY)
  81     }
  82     /// Create a new `MemWriter`, allocating at least `n` bytes for
  83     /// the internal buffer.
  84     #[inline]
  85     pub fn with_capacity(n: usize) -> MemWriter {
  86         MemWriter::from_vec(Vec::with_capacity(n))
  87     }
  88     /// Create a new `MemWriter` that will append to an existing `Vec`.
  89     #[inline]
  90     pub fn from_vec(buf: Vec<u8>) -> MemWriter {
  91         MemWriter { buf: buf }
  92     }
  93
  94     /// Acquires an immutable reference to the underlying buffer of this
  95     /// `MemWriter`.
  96     #[inline]
  97     pub fn get_ref<'a>(&'a self) -> &'a [u8] { &self.buf }
  98
  99     /// Unwraps this `MemWriter`, returning the underlying buffer
 100     #[inline]
 101     pub fn into_inner(self) -> Vec<u8> { self.buf }
 102 }
 103
 104 impl Writer for MemWriter {
 105     #[inline]
 106     #[allow(deprecated)]
 107     fn write_all(&mut self, buf: &[u8]) -> IoResult<()> {
 108         self.buf.push_all(buf);
 109         Ok(())
 110     }
 111 }
 112
 113 /// Reads from an owned byte vector
 114 ///
 115 /// # Examples
 116 ///
 117 /// ```
 118 /// # #![feature(old_io)]
 119 /// # #![allow(unused_must_use)]
 120 /// use std::old_io::*;
 121 ///
 122 /// let mut r = MemReader::new(vec!(0, 1, 2));
 123 ///
 124 /// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2]);
 125 /// ```
 126 pub struct MemReader {
 127     buf: Vec<u8>,
 128     pos: usize
 129 }
 130
 131 impl MemReader {
 132     /// Creates a new `MemReader` which will read the buffer given. The buffer
 133     /// can be re-acquired through `unwrap`
 134     #[inline]
 135     pub fn new(buf: Vec<u8>) -> MemReader {
 136         MemReader {
 137             buf: buf,
 138             pos: 0
 139         }
 140     }
 141
 142     /// Tests whether this reader has read all bytes in its buffer.
 143     ///
 144     /// If `true`, then this will no longer return bytes from `read`.
 145     #[inline]
 146     pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
 147
 148     /// Acquires an immutable reference to the underlying buffer of this
 149     /// `MemReader`.
 150     ///
 151     /// No method is exposed for acquiring a mutable reference to the buffer
 152     /// because it could corrupt the state of this `MemReader`.
 153     #[inline]
 154     pub fn get_ref<'a>(&'a self) -> &'a [u8] { &self.buf }
 155
 156     /// Unwraps this `MemReader`, returning the underlying buffer
 157     #[inline]
 158     pub fn into_inner(self) -> Vec<u8> { self.buf }
 159 }
 160
 161 impl Reader for MemReader {
 162     #[inline]
 163     fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
 164         if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
 165
 166         let write_len = min(buf.len(), self.buf.len() - self.pos);
 167         {
 168             let input = &self.buf[self.pos.. self.pos + write_len];
 169             let output = &mut buf[..write_len];
 170             assert_eq!(input.len(), output.len());
 171             slice::bytes::copy_memory(input, output);
 172         }
 173         self.pos += write_len;
 174         assert!(self.pos <= self.buf.len());
 175
 176         return Ok(write_len);
 177     }
 178 }
 179
 180 impl Seek for MemReader {
 181     #[inline]
 182     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 183
 184     #[inline]
 185     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 186         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 187         self.pos = new as usize;
 188         Ok(())
 189     }
 190 }
 191
 192 impl Buffer for MemReader {
 193     #[inline]
 194     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
 195         if self.pos < self.buf.len() {
 196             Ok(&self.buf[self.pos..])
 197         } else {
 198             Err(old_io::standard_error(old_io::EndOfFile))
 199         }
 200     }
 201
 202     #[inline]
 203     fn consume(&mut self, amt: usize) { self.pos += amt; }
 204 }
 205
 206 impl<'a> Reader for &'a [u8] {
 207     #[inline]
 208     fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
 209         if self.is_empty() { return Err(old_io::standard_error(old_io::EndOfFile)); }
 210
 211         let write_len = min(buf.len(), self.len());
 212         {
 213             let input = &self[..write_len];
 214             let output = &mut buf[.. write_len];
 215             slice::bytes::copy_memory(input, output);
 216         }
 217
 218         *self = &self[write_len..];
 219
 220         Ok(write_len)
 221     }
 222 }
 223
 224 impl<'a> Buffer for &'a [u8] {
 225     #[inline]
 226     fn fill_buf(&mut self) -> IoResult<&[u8]> {
 227         if self.is_empty() {
 228             Err(old_io::standard_error(old_io::EndOfFile))
 229         } else {
 230             Ok(*self)
 231         }
 232     }
 233
 234     #[inline]
 235     fn consume(&mut self, amt: usize) {
 236         *self = &self[amt..];
 237     }
 238 }
 239
 240
 241 /// Writes to a fixed-size byte slice
 242 ///
 243 /// If a write will not fit in the buffer, it returns an error and does not
 244 /// write any data.
 245 ///
 246 /// # Examples
 247 ///
 248 /// ```
 249 /// # #![feature(old_io, io)]
 250 /// # #![allow(unused_must_use)]
 251 /// use std::old_io::*;
 252 ///
 253 /// let mut buf = [0; 4];
 254 /// {
 255 ///     let mut w = BufWriter::new(&mut buf);
 256 ///     w.write(&[0, 1, 2]);
 257 /// }
 258 /// assert!(buf == [0, 1, 2, 0]);
 259 /// ```
 260 pub struct BufWriter<'a> {
 261     buf: &'a mut [u8],
 262     pos: usize
 263 }
 264
 265 impl<'a> BufWriter<'a> {
 266     /// Creates a new `BufWriter` which will wrap the specified buffer. The
 267     /// writer initially starts at position 0.
 268     #[inline]
 269     pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
 270         BufWriter {
 271             buf: buf,
 272             pos: 0
 273         }
 274     }
 275 }
 276
 277 impl<'a> Writer for BufWriter<'a> {
 278     #[inline]
 279     fn write_all(&mut self, src: &[u8]) -> IoResult<()> {
 280         let dst = &mut self.buf[self.pos..];
 281         let dst_len = dst.len();
 282
 283         if dst_len == 0 {
 284             return Err(old_io::standard_error(old_io::EndOfFile));
 285         }
 286
 287         let src_len = src.len();
 288
 289         if dst_len >= src_len {
 290             slice::bytes::copy_memory(src, dst);
 291
 292             self.pos += src_len;
 293
 294             Ok(())
 295         } else {
 296             slice::bytes::copy_memory(&src[..dst_len], dst);
 297
 298             self.pos += dst_len;
 299
 300             Err(old_io::standard_error(old_io::ShortWrite(dst_len)))
 301         }
 302     }
 303 }
 304
 305 impl<'a> Seek for BufWriter<'a> {
 306     #[inline]
 307     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 308
 309     #[inline]
 310     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 311         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 312         self.pos = min(new as usize, self.buf.len());
 313         Ok(())
 314     }
 315 }
 316
 317 /// Reads from a fixed-size byte slice
 318 ///
 319 /// # Examples
 320 ///
 321 /// ```
 322 /// # #![feature(old_io)]
 323 /// # #![allow(unused_must_use)]
 324 /// use std::old_io::*;
 325 ///
 326 /// let buf = [0, 1, 2, 3];
 327 /// let mut r = BufReader::new(&buf);
 328 ///
 329 /// assert_eq!(r.read_to_end().unwrap(), [0, 1, 2, 3]);
 330 /// ```
 331 pub struct BufReader<'a> {
 332     buf: &'a [u8],
 333     pos: usize
 334 }
 335
 336 impl<'a> BufReader<'a> {
 337     /// Creates a new buffered reader which will read the specified buffer
 338     #[inline]
 339     pub fn new(buf: &'a [u8]) -> BufReader<'a> {
 340         BufReader {
 341             buf: buf,
 342             pos: 0
 343         }
 344     }
 345
 346     /// Tests whether this reader has read all bytes in its buffer.
 347     ///
 348     /// If `true`, then this will no longer return bytes from `read`.
 349     #[inline]
 350     pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
 351 }
 352
 353 impl<'a> Reader for BufReader<'a> {
 354     #[inline]
 355     fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
 356         if self.eof() { return Err(old_io::standard_error(old_io::EndOfFile)) }
 357
 358         let write_len = min(buf.len(), self.buf.len() - self.pos);
 359         {
 360             let input = &self.buf[self.pos.. self.pos + write_len];
 361             let output = &mut buf[..write_len];
 362             assert_eq!(input.len(), output.len());
 363             slice::bytes::copy_memory(input, output);
 364         }
 365         self.pos += write_len;
 366         assert!(self.pos <= self.buf.len());
 367
 368         return Ok(write_len);
 369      }
 370 }
 371
 372 impl<'a> Seek for BufReader<'a> {
 373     #[inline]
 374     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 375
 376     #[inline]
 377     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 378         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 379         self.pos = new as usize;
 380         Ok(())
 381     }
 382 }
 383
 384 impl<'a> Buffer for BufReader<'a> {
 385     #[inline]
 386     fn fill_buf(&mut self) -> IoResult<&[u8]> {
 387         if self.pos < self.buf.len() {
 388             Ok(&self.buf[self.pos..])
 389         } else {
 390             Err(old_io::standard_error(old_io::EndOfFile))
 391         }
 392     }
 393
 394     #[inline]
 395     fn consume(&mut self, amt: usize) { self.pos += amt; }
 396 }
 397
 398 #[cfg(test)]
 399 mod test {
 400     extern crate test as test_crate;
 401     use old_io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek, Buffer};
 402     use prelude::v1::{Ok, Err, Vec,  AsSlice};
 403     use prelude::v1::Iterator;
 404     use old_io;
 405     use iter::repeat;
 406     use self::test_crate::Bencher;
 407     use super::*;
 408
 409     #[test]
 410     fn test_vec_writer() {
 411         let mut writer = Vec::new();
 412         writer.write(&[0]).unwrap();
 413         writer.write(&[1, 2, 3]).unwrap();
 414         writer.write(&[4, 5, 6, 7]).unwrap();
 415         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 416         assert_eq!(writer, b);
 417     }
 418
 419     #[test]
 420     fn test_mem_writer() {
 421         let mut writer = MemWriter::new();
 422         writer.write(&[0]).unwrap();
 423         writer.write(&[1, 2, 3]).unwrap();
 424         writer.write(&[4, 5, 6, 7]).unwrap();
 425         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 426         assert_eq!(writer.get_ref(), b);
 427     }
 428
 429     #[test]
 430     fn test_buf_writer() {
 431         let mut buf = [0 as u8; 9];
 432         {
 433             let mut writer = BufWriter::new(&mut buf);
 434             assert_eq!(writer.tell(), Ok(0));
 435             writer.write(&[0]).unwrap();
 436             assert_eq!(writer.tell(), Ok(1));
 437             writer.write(&[1, 2, 3]).unwrap();
 438             writer.write(&[4, 5, 6, 7]).unwrap();
 439             assert_eq!(writer.tell(), Ok(8));
 440             writer.write(&[]).unwrap();
 441             assert_eq!(writer.tell(), Ok(8));
 442
 443             assert_eq!(writer.write(&[8, 9]).err().unwrap().kind, old_io::ShortWrite(1));
 444             assert_eq!(writer.write(&[10]).err().unwrap().kind, old_io::EndOfFile);
 445         }
 446         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 447         assert_eq!(buf, b);
 448     }
 449
 450     #[test]
 451     fn test_buf_writer_seek() {
 452         let mut buf = [0 as u8; 8];
 453         {
 454             let mut writer = BufWriter::new(&mut buf);
 455             assert_eq!(writer.tell(), Ok(0));
 456             writer.write(&[1]).unwrap();
 457             assert_eq!(writer.tell(), Ok(1));
 458
 459             writer.seek(2, SeekSet).unwrap();
 460             assert_eq!(writer.tell(), Ok(2));
 461             writer.write(&[2]).unwrap();
 462             assert_eq!(writer.tell(), Ok(3));
 463
 464             writer.seek(-2, SeekCur).unwrap();
 465             assert_eq!(writer.tell(), Ok(1));
 466             writer.write(&[3]).unwrap();
 467             assert_eq!(writer.tell(), Ok(2));
 468
 469             writer.seek(-1, SeekEnd).unwrap();
 470             assert_eq!(writer.tell(), Ok(7));
 471             writer.write(&[4]).unwrap();
 472             assert_eq!(writer.tell(), Ok(8));
 473
 474         }
 475         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 476         assert_eq!(buf, b);
 477     }
 478
 479     #[test]
 480     fn test_buf_writer_error() {
 481         let mut buf = [0 as u8; 2];
 482         let mut writer = BufWriter::new(&mut buf);
 483         writer.write(&[0]).unwrap();
 484
 485         match writer.write(&[0, 0]) {
 486             Ok(..) => panic!(),
 487             Err(e) => assert_eq!(e.kind, old_io::ShortWrite(1)),
 488         }
 489     }
 490
 491     #[test]
 492     fn test_mem_reader() {
 493         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
 494         let mut buf = [];
 495         assert_eq!(reader.read(&mut buf), Ok(0));
 496         assert_eq!(reader.tell(), Ok(0));
 497         let mut buf = [0];
 498         assert_eq!(reader.read(&mut buf), Ok(1));
 499         assert_eq!(reader.tell(), Ok(1));
 500         let b: &[_] = &[0];
 501         assert_eq!(buf, b);
 502         let mut buf = [0; 4];
 503         assert_eq!(reader.read(&mut buf), Ok(4));
 504         assert_eq!(reader.tell(), Ok(5));
 505         let b: &[_] = &[1, 2, 3, 4];
 506         assert_eq!(buf, b);
 507         assert_eq!(reader.read(&mut buf), Ok(3));
 508         let b: &[_] = &[5, 6, 7];
 509         assert_eq!(&buf[..3], b);
 510         assert!(reader.read(&mut buf).is_err());
 511         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
 512         assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
 513         assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
 514         assert!(reader.read(&mut buf).is_err());
 515     }
 516
 517     #[test]
 518     fn test_slice_reader() {
 519         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 520         let mut reader = &mut &*in_buf;
 521         let mut buf = [];
 522         assert_eq!(reader.read(&mut buf), Ok(0));
 523         let mut buf = [0];
 524         assert_eq!(reader.read(&mut buf), Ok(1));
 525         assert_eq!(reader.len(), 7);
 526         let b: &[_] = &[0];
 527         assert_eq!(buf, b);
 528         let mut buf = [0; 4];
 529         assert_eq!(reader.read(&mut buf), Ok(4));
 530         assert_eq!(reader.len(), 3);
 531         let b: &[_] = &[1, 2, 3, 4];
 532         assert_eq!(buf, b);
 533         assert_eq!(reader.read(&mut buf), Ok(3));
 534         let b: &[_] = &[5, 6, 7];
 535         assert_eq!(&buf[..3], b);
 536         assert!(reader.read(&mut buf).is_err());
 537         let mut reader = &mut &*in_buf;
 538         assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
 539         assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
 540         assert!(reader.read(&mut buf).is_err());
 541     }
 542
 543     #[test]
 544     fn test_buf_reader() {
 545         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 546         let mut reader = BufReader::new(&in_buf);
 547         let mut buf = [];
 548         assert_eq!(reader.read(&mut buf), Ok(0));
 549         assert_eq!(reader.tell(), Ok(0));
 550         let mut buf = [0];
 551         assert_eq!(reader.read(&mut buf), Ok(1));
 552         assert_eq!(reader.tell(), Ok(1));
 553         let b: &[_] = &[0];
 554         assert_eq!(buf, b);
 555         let mut buf = [0; 4];
 556         assert_eq!(reader.read(&mut buf), Ok(4));
 557         assert_eq!(reader.tell(), Ok(5));
 558         let b: &[_] = &[1, 2, 3, 4];
 559         assert_eq!(buf, b);
 560         assert_eq!(reader.read(&mut buf), Ok(3));
 561         let b: &[_] = &[5, 6, 7];
 562         assert_eq!(&buf[..3], b);
 563         assert!(reader.read(&mut buf).is_err());
 564         let mut reader = BufReader::new(&in_buf);
 565         assert_eq!(reader.read_until(3).unwrap(), [0, 1, 2, 3]);
 566         assert_eq!(reader.read_until(3).unwrap(), [4, 5, 6, 7]);
 567         assert!(reader.read(&mut buf).is_err());
 568     }
 569
 570     #[test]
 571     fn test_read_char() {
 572         let b = b"Vi\xE1\xBB\x87t";
 573         let mut r = BufReader::new(b);
 574         assert_eq!(r.read_char(), Ok('V'));
 575         assert_eq!(r.read_char(), Ok('i'));
 576         assert_eq!(r.read_char(), Ok('ệ'));
 577         assert_eq!(r.read_char(), Ok('t'));
 578         assert!(r.read_char().is_err());
 579     }
 580
 581     #[test]
 582     fn test_read_bad_char() {
 583         let b = b"\x80";
 584         let mut r = BufReader::new(b);
 585         assert!(r.read_char().is_err());
 586     }
 587
 588     #[test]
 589     fn test_write_strings() {
 590         let mut writer = MemWriter::new();
 591         writer.write_str("testing").unwrap();
 592         writer.write_line("testing").unwrap();
 593         writer.write_str("testing").unwrap();
 594         let mut r = BufReader::new(writer.get_ref());
 595         assert_eq!(r.read_to_string().unwrap(), "testingtesting\ntesting");
 596     }
 597
 598     #[test]
 599     fn test_write_char() {
 600         let mut writer = MemWriter::new();
 601         writer.write_char('a').unwrap();
 602         writer.write_char('\n').unwrap();
 603         writer.write_char('ệ').unwrap();
 604         let mut r = BufReader::new(writer.get_ref());
 605         assert_eq!(r.read_to_string().unwrap(), "a\nệ");
 606     }
 607
 608     #[test]
 609     fn test_read_whole_string_bad() {
 610         let buf = [0xff];
 611         let mut r = BufReader::new(&buf);
 612         match r.read_to_string() {
 613             Ok(..) => panic!(),
 614             Err(..) => {}
 615         }
 616     }
 617
 618     #[test]
 619     fn seek_past_end() {
 620         let buf = [0xff];
 621         let mut r = BufReader::new(&buf);
 622         r.seek(10, SeekSet).unwrap();
 623         assert!(r.read(&mut []).is_err());
 624
 625         let mut r = MemReader::new(vec!(10));
 626         r.seek(10, SeekSet).unwrap();
 627         assert!(r.read(&mut []).is_err());
 628
 629         let mut buf = [0];
 630         let mut r = BufWriter::new(&mut buf);
 631         r.seek(10, SeekSet).unwrap();
 632         assert!(r.write(&[3]).is_err());
 633     }
 634
 635     #[test]
 636     fn seek_before_0() {
 637         let buf = [0xff];
 638         let mut r = BufReader::new(&buf);
 639         assert!(r.seek(-1, SeekSet).is_err());
 640
 641         let mut r = MemReader::new(vec!(10));
 642         assert!(r.seek(-1, SeekSet).is_err());
 643
 644         let mut buf = [0];
 645         let mut r = BufWriter::new(&mut buf);
 646         assert!(r.seek(-1, SeekSet).is_err());
 647     }
 648
 649     #[test]
 650     fn io_read_at_least() {
 651         let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
 652         let mut buf = [0; 3];
 653         assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
 654         let b: &[_] = &[1, 2, 3];
 655         assert_eq!(buf, b);
 656         assert!(r.read_at_least(0, &mut buf[..0]).is_ok());
 657         assert_eq!(buf, b);
 658         assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
 659         let b: &[_] = &[4, 5, 6];
 660         assert_eq!(buf, b);
 661         assert!(r.read_at_least(buf.len(), &mut buf).is_err());
 662         let b: &[_] = &[7, 8, 6];
 663         assert_eq!(buf, b);
 664     }
 665
 666     fn do_bench_mem_writer(b: &mut Bencher, times: usize, len: usize) {
 667         let src: Vec<u8> = repeat(5).take(len).collect();
 668
 669         b.bytes = (times * len) as u64;
 670         b.iter(|| {
 671             let mut wr = MemWriter::new();
 672             for _ in 0..times {
 673                 wr.write(&src).unwrap();
 674             }
 675
 676             let v = wr.into_inner();
 677             assert_eq!(v.len(), times * len);
 678             assert!(v.iter().all(|x| *x == 5));
 679         });
 680     }
 681
 682     #[bench]
 683     fn bench_mem_writer_001_0000(b: &mut Bencher) {
 684         do_bench_mem_writer(b, 1, 0)
 685     }
 686
 687     #[bench]
 688     fn bench_mem_writer_001_0010(b: &mut Bencher) {
 689         do_bench_mem_writer(b, 1, 10)
 690     }
 691
 692     #[bench]
 693     fn bench_mem_writer_001_0100(b: &mut Bencher) {
 694         do_bench_mem_writer(b, 1, 100)
 695     }
 696
 697     #[bench]
 698     fn bench_mem_writer_001_1000(b: &mut Bencher) {
 699         do_bench_mem_writer(b, 1, 1000)
 700     }
 701
 702     #[bench]
 703     fn bench_mem_writer_100_0000(b: &mut Bencher) {
 704         do_bench_mem_writer(b, 100, 0)
 705     }
 706
 707     #[bench]
 708     fn bench_mem_writer_100_0010(b: &mut Bencher) {
 709         do_bench_mem_writer(b, 100, 10)
 710     }
 711
 712     #[bench]
 713     fn bench_mem_writer_100_0100(b: &mut Bencher) {
 714         do_bench_mem_writer(b, 100, 100)
 715     }
 716
 717     #[bench]
 718     fn bench_mem_writer_100_1000(b: &mut Bencher) {
 719         do_bench_mem_writer(b, 100, 1000)
 720     }
 721
 722     #[bench]
 723     fn bench_mem_reader(b: &mut Bencher) {
 724         b.iter(|| {
 725             let buf = [5 as u8; 100].to_vec();
 726             {
 727                 let mut rdr = MemReader::new(buf);
 728                 for _i in 0..10 {
 729                     let mut buf = [0 as u8; 10];
 730                     rdr.read(&mut buf).unwrap();
 731                     assert_eq!(buf, [5; 10]);
 732                 }
 733             }
 734         });
 735     }
 736
 737     #[bench]
 738     fn bench_buf_writer(b: &mut Bencher) {
 739         b.iter(|| {
 740             let mut buf = [0 as u8; 100];
 741             {
 742                 let mut wr = BufWriter::new(&mut buf);
 743                 for _i in 0..10 {
 744                     wr.write(&[5; 10]).unwrap();
 745                 }
 746             }
 747             assert_eq!(buf.as_slice(), [5; 100].as_slice());
 748         });
 749     }
 750
 751     #[bench]
 752     fn bench_buf_reader(b: &mut Bencher) {
 753         b.iter(|| {
 754             let buf = [5 as u8; 100];
 755             {
 756                 let mut rdr = BufReader::new(&buf);
 757                 for _i in 0..10 {
 758                     let mut buf = [0 as u8; 10];
 759                     rdr.read(&mut buf).unwrap();
 760                     assert_eq!(buf, [5; 10]);
 761                 }
 762             }
 763         });
 764     }
 765 }