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