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