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