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 #![allow(deprecated)]
  16
  17 use cmp::min;
  18 use option::Option::None;
  19 use result::Result::{Err, Ok};
  20 use io;
  21 use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult};
  22 use slice::{mod, AsSlice, SliceExt};
  23 use vec::Vec;
  24
  25 const BUF_CAPACITY: uint = 128;
  26
  27 fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64> {
  28     // compute offset as signed and clamp to prevent overflow
  29     let pos = match seek {
  30         io::SeekSet => 0,
  31         io::SeekEnd => end,
  32         io::SeekCur => cur,
  33     } as i64;
  34
  35     if offset + pos < 0 {
  36         Err(IoError {
  37             kind: io::InvalidInput,
  38             desc: "invalid seek to a negative offset",
  39             detail: None
  40         })
  41     } else {
  42         Ok((offset + pos) as u64)
  43     }
  44 }
  45
  46 impl Writer for Vec<u8> {
  47     #[inline]
  48     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
  49         self.push_all(buf);
  50         Ok(())
  51     }
  52 }
  53
  54 /// Writes to an owned, growable byte vector
  55 ///
  56 /// # Example
  57 ///
  58 /// ```rust
  59 /// # #![allow(unused_must_use)]
  60 /// use std::io::MemWriter;
  61 ///
  62 /// let mut w = MemWriter::new();
  63 /// w.write(&[0, 1, 2]);
  64 ///
  65 /// assert_eq!(w.into_inner(), vec!(0, 1, 2));
  66 /// ```
  67 #[deprecated = "use the Vec<u8> Writer implementation directly"]
  68 #[deriving(Clone)]
  69 pub struct MemWriter {
  70     buf: Vec<u8>,
  71 }
  72
  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     /// Deprecated, use into_inner() instead
 101     #[deprecated = "renamed to into_inner()"]
 102     pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
 103 }
 104
 105 impl Writer for MemWriter {
 106     #[inline]
 107     fn write(&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 /// # Example
 116 ///
 117 /// ```rust
 118 /// # #![allow(unused_must_use)]
 119 /// use std::io::MemReader;
 120 ///
 121 /// let mut r = MemReader::new(vec!(0, 1, 2));
 122 ///
 123 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2));
 124 /// ```
 125 pub struct MemReader {
 126     buf: Vec<u8>,
 127     pos: uint
 128 }
 129
 130 impl MemReader {
 131     /// Creates a new `MemReader` which will read the buffer given. The buffer
 132     /// can be re-acquired through `unwrap`
 133     #[inline]
 134     pub fn new(buf: Vec<u8>) -> MemReader {
 135         MemReader {
 136             buf: buf,
 137             pos: 0
 138         }
 139     }
 140
 141     /// Tests whether this reader has read all bytes in its buffer.
 142     ///
 143     /// If `true`, then this will no longer return bytes from `read`.
 144     #[inline]
 145     pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
 146
 147     /// Acquires an immutable reference to the underlying buffer of this
 148     /// `MemReader`.
 149     ///
 150     /// No method is exposed for acquiring a mutable reference to the buffer
 151     /// because it could corrupt the state of this `MemReader`.
 152     #[inline]
 153     pub fn get_ref<'a>(&'a self) -> &'a [u8] { self.buf.as_slice() }
 154
 155     /// Unwraps this `MemReader`, returning the underlying buffer
 156     #[inline]
 157     pub fn into_inner(self) -> Vec<u8> { self.buf }
 158
 159     /// Deprecated, use into_inner() instead
 160     #[deprecated = "renamed to into_inner()"]
 161     pub fn unwrap(self) -> Vec<u8> { self.into_inner() }
 162 }
 163
 164 impl Reader for MemReader {
 165     #[inline]
 166     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 167         if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
 168
 169         let write_len = min(buf.len(), self.buf.len() - self.pos);
 170         {
 171             let input = self.buf[self.pos.. self.pos + write_len];
 172             let output = buf.slice_to_mut(write_len);
 173             assert_eq!(input.len(), output.len());
 174             slice::bytes::copy_memory(output, input);
 175         }
 176         self.pos += write_len;
 177         assert!(self.pos <= self.buf.len());
 178
 179         return Ok(write_len);
 180     }
 181 }
 182
 183 impl Seek for MemReader {
 184     #[inline]
 185     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 186
 187     #[inline]
 188     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 189         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 190         self.pos = new as uint;
 191         Ok(())
 192     }
 193 }
 194
 195 impl Buffer for MemReader {
 196     #[inline]
 197     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
 198         if self.pos < self.buf.len() {
 199             Ok(self.buf[self.pos..])
 200         } else {
 201             Err(io::standard_error(io::EndOfFile))
 202         }
 203     }
 204
 205     #[inline]
 206     fn consume(&mut self, amt: uint) { self.pos += amt; }
 207 }
 208
 209 impl<'a> Reader for &'a [u8] {
 210     #[inline]
 211     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 212         if self.is_empty() { return Err(io::standard_error(io::EndOfFile)); }
 213
 214         let write_len = min(buf.len(), self.len());
 215         {
 216             let input = self[..write_len];
 217             let output = buf.slice_to_mut(write_len);
 218             slice::bytes::copy_memory(output, input);
 219         }
 220
 221         *self = self.slice_from(write_len);
 222
 223         Ok(write_len)
 224     }
 225 }
 226
 227 impl<'a> Buffer for &'a [u8] {
 228     #[inline]
 229     fn fill_buf(&mut self) -> IoResult<&[u8]> {
 230         if self.is_empty() {
 231             Err(io::standard_error(io::EndOfFile))
 232         } else {
 233             Ok(*self)
 234         }
 235     }
 236
 237     #[inline]
 238     fn consume(&mut self, amt: uint) {
 239         *self = self[amt..];
 240     }
 241 }
 242
 243
 244 /// Writes to a fixed-size byte slice
 245 ///
 246 /// If a write will not fit in the buffer, it returns an error and does not
 247 /// write any data.
 248 ///
 249 /// # Example
 250 ///
 251 /// ```rust
 252 /// # #![allow(unused_must_use)]
 253 /// use std::io::BufWriter;
 254 ///
 255 /// let mut buf = [0; 4];
 256 /// {
 257 ///     let mut w = BufWriter::new(&mut buf);
 258 ///     w.write(&[0, 1, 2]);
 259 /// }
 260 /// assert!(buf == [0, 1, 2, 0]);
 261 /// ```
 262 pub struct BufWriter<'a> {
 263     buf: &'a mut [u8],
 264     pos: uint
 265 }
 266
 267 impl<'a> BufWriter<'a> {
 268     /// Creates a new `BufWriter` which will wrap the specified buffer. The
 269     /// writer initially starts at position 0.
 270     #[inline]
 271     pub fn new(buf: &'a mut [u8]) -> BufWriter<'a> {
 272         BufWriter {
 273             buf: buf,
 274             pos: 0
 275         }
 276     }
 277 }
 278
 279 impl<'a> Writer for BufWriter<'a> {
 280     #[inline]
 281     fn write(&mut self, src: &[u8]) -> IoResult<()> {
 282         let dst = self.buf.slice_from_mut(self.pos);
 283         let dst_len = dst.len();
 284
 285         if dst_len == 0 {
 286             return Err(io::standard_error(io::EndOfFile));
 287         }
 288
 289         let src_len = src.len();
 290
 291         if dst_len >= src_len {
 292             slice::bytes::copy_memory(dst, src);
 293
 294             self.pos += src_len;
 295
 296             Ok(())
 297         } else {
 298             slice::bytes::copy_memory(dst, src[..dst_len]);
 299
 300             self.pos += dst_len;
 301
 302             Err(io::standard_error(io::ShortWrite(dst_len)))
 303         }
 304     }
 305 }
 306
 307 impl<'a> Seek for BufWriter<'a> {
 308     #[inline]
 309     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 310
 311     #[inline]
 312     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 313         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 314         self.pos = min(new as uint, self.buf.len());
 315         Ok(())
 316     }
 317 }
 318
 319 /// Reads from a fixed-size byte slice
 320 ///
 321 /// # Example
 322 ///
 323 /// ```rust
 324 /// # #![allow(unused_must_use)]
 325 /// use std::io::BufReader;
 326 ///
 327 /// let buf = [0, 1, 2, 3];
 328 /// let mut r = BufReader::new(&buf);
 329 ///
 330 /// assert_eq!(r.read_to_end().unwrap(), vec![0, 1, 2, 3]);
 331 /// ```
 332 pub struct BufReader<'a> {
 333     buf: &'a [u8],
 334     pos: uint
 335 }
 336
 337 impl<'a> BufReader<'a> {
 338     /// Creates a new buffered reader which will read the specified buffer
 339     #[inline]
 340     pub fn new(buf: &'a [u8]) -> BufReader<'a> {
 341         BufReader {
 342             buf: buf,
 343             pos: 0
 344         }
 345     }
 346
 347     /// Tests whether this reader has read all bytes in its buffer.
 348     ///
 349     /// If `true`, then this will no longer return bytes from `read`.
 350     #[inline]
 351     pub fn eof(&self) -> bool { self.pos >= self.buf.len() }
 352 }
 353
 354 impl<'a> Reader for BufReader<'a> {
 355     #[inline]
 356     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
 357         if self.eof() { return Err(io::standard_error(io::EndOfFile)) }
 358
 359         let write_len = min(buf.len(), self.buf.len() - self.pos);
 360         {
 361             let input = self.buf[self.pos.. self.pos + write_len];
 362             let output = buf.slice_to_mut(write_len);
 363             assert_eq!(input.len(), output.len());
 364             slice::bytes::copy_memory(output, input);
 365         }
 366         self.pos += write_len;
 367         assert!(self.pos <= self.buf.len());
 368
 369         return Ok(write_len);
 370      }
 371 }
 372
 373 impl<'a> Seek for BufReader<'a> {
 374     #[inline]
 375     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
 376
 377     #[inline]
 378     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
 379         let new = try!(combine(style, self.pos, self.buf.len(), pos));
 380         self.pos = new as uint;
 381         Ok(())
 382     }
 383 }
 384
 385 impl<'a> Buffer for BufReader<'a> {
 386     #[inline]
 387     fn fill_buf(&mut self) -> IoResult<&[u8]> {
 388         if self.pos < self.buf.len() {
 389             Ok(self.buf[self.pos..])
 390         } else {
 391             Err(io::standard_error(io::EndOfFile))
 392         }
 393     }
 394
 395     #[inline]
 396     fn consume(&mut self, amt: uint) { self.pos += amt; }
 397 }
 398
 399 #[cfg(test)]
 400 mod test {
 401     extern crate "test" as test_crate;
 402     use prelude::v1::*;
 403
 404     use super::*;
 405     use io::{SeekSet, SeekCur, SeekEnd};
 406     use io;
 407     use self::test_crate::Bencher;
 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.as_slice(), 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]).unwrap_err().kind, io::ShortWrite(1));
 444             assert_eq!(writer.write(&[10]).unwrap_err().kind, 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, 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[0..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(), vec!(0, 1, 2, 3));
 513         assert_eq!(reader.read_until(3).unwrap(), vec!(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.as_slice();
 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.as_slice(), 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.as_slice(), b);
 533         assert_eq!(reader.read(&mut buf), Ok(3));
 534         let b: &[_] = &[5, 6, 7];
 535         assert_eq!(buf[0..3], b);
 536         assert!(reader.read(&mut buf).is_err());
 537         let mut reader = &mut in_buf.as_slice();
 538         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
 539         assert_eq!(reader.read_until(3).unwrap(), vec!(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.as_slice());
 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[0..3], b);
 563         assert!(reader.read(&mut buf).is_err());
 564         let mut reader = BufReader::new(in_buf.as_slice());
 565         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
 566         assert_eq!(reader.read_until(3).unwrap(), vec!(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, buf.slice_to_mut(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: uint, len: uint) {
 667         let src: Vec<u8> = Vec::from_elem(len, 5);
 668
 669         b.bytes = (times * len) as u64;
 670         b.iter(|| {
 671             let mut wr = MemWriter::new();
 672             for _ in range(0, times) {
 673                 wr.write(src.as_slice()).unwrap();
 674             }
 675
 676             let v = wr.unwrap();
 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 range(0u, 10) {
 729                     let mut buf = [0 as u8; 10];
 730                     rdr.read(&mut buf).unwrap();
 731                     assert_eq!(buf.as_slice(), [5; 10].as_slice());
 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 range(0u, 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 range(0u, 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 }