src/libstd/io/cursor.rs

   1 use crate::io::prelude::*;
   2
   3 use crate::cmp;
   4 use crate::io::{self, Initializer, SeekFrom, Error, ErrorKind, IoSlice, IoSliceMut};
   5
   6 use core::convert::TryInto;
   7
   8 /// A `Cursor` wraps an in-memory buffer and provides it with a
   9 /// [`Seek`] implementation.
  10 ///
  11 /// `Cursor`s are used with in-memory buffers, anything implementing
  12 /// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
  13 /// allowing these buffers to be used anywhere you might use a reader or writer
  14 /// that does actual I/O.
  15 ///
  16 /// The standard library implements some I/O traits on various types which
  17 /// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
  18 /// `Cursor<`[`&[u8]`][bytes]`>`.
  19 ///
  20 /// # Examples
  21 ///
  22 /// We may want to write bytes to a [`File`] in our production
  23 /// code, but use an in-memory buffer in our tests. We can do this with
  24 /// `Cursor`:
  25 ///
  26 /// [`Seek`]: trait.Seek.html
  27 /// [`Read`]: ../../std/io/trait.Read.html
  28 /// [`Write`]: ../../std/io/trait.Write.html
  29 /// [`Vec`]: ../../std/vec/struct.Vec.html
  30 /// [bytes]: ../../std/primitive.slice.html
  31 /// [`File`]: ../fs/struct.File.html
  32 ///
  33 /// ```no_run
  34 /// use std::io::prelude::*;
  35 /// use std::io::{self, SeekFrom};
  36 /// use std::fs::File;
  37 ///
  38 /// // a library function we've written
  39 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
  40 ///     writer.seek(SeekFrom::End(-10))?;
  41 ///
  42 ///     for i in 0..10 {
  43 ///         writer.write(&[i])?;
  44 ///     }
  45 ///
  46 ///     // all went well
  47 ///     Ok(())
  48 /// }
  49 ///
  50 /// # fn foo() -> io::Result<()> {
  51 /// // Here's some code that uses this library function.
  52 /// //
  53 /// // We might want to use a BufReader here for efficiency, but let's
  54 /// // keep this example focused.
  55 /// let mut file = File::create("foo.txt")?;
  56 ///
  57 /// write_ten_bytes_at_end(&mut file)?;
  58 /// # Ok(())
  59 /// # }
  60 ///
  61 /// // now let's write a test
  62 /// #[test]
  63 /// fn test_writes_bytes() {
  64 ///     // setting up a real File is much slower than an in-memory buffer,
  65 ///     // let's use a cursor instead
  66 ///     use std::io::Cursor;
  67 ///     let mut buff = Cursor::new(vec![0; 15]);
  68 ///
  69 ///     write_ten_bytes_at_end(&mut buff).unwrap();
  70 ///
  71 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  72 /// }
  73 /// ```
  74 #[stable(feature = "rust1", since = "1.0.0")]
  75 #[derive(Clone, Debug)]
  76 pub struct Cursor<T> {
  77     inner: T,
  78     pos: u64,
  79 }
  80
  81 impl<T> Cursor<T> {
  82     /// Creates a new cursor wrapping the provided underlying in-memory buffer.
  83     ///
  84     /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
  85     /// is not empty. So writing to cursor starts with overwriting `Vec`
  86     /// content, not with appending to it.
  87     ///
  88     /// # Examples
  89     ///
  90     /// ```
  91     /// use std::io::Cursor;
  92     ///
  93     /// let buff = Cursor::new(Vec::new());
  94     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
  95     /// # force_inference(&buff);
  96     /// ```
  97     #[stable(feature = "rust1", since = "1.0.0")]
  98     pub fn new(inner: T) -> Cursor<T> {
  99         Cursor { pos: 0, inner: inner }
 100     }
 101
 102     /// Consumes this cursor, returning the underlying value.
 103     ///
 104     /// # Examples
 105     ///
 106     /// ```
 107     /// use std::io::Cursor;
 108     ///
 109     /// let buff = Cursor::new(Vec::new());
 110     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 111     /// # force_inference(&buff);
 112     ///
 113     /// let vec = buff.into_inner();
 114     /// ```
 115     #[stable(feature = "rust1", since = "1.0.0")]
 116     pub fn into_inner(self) -> T { self.inner }
 117
 118     /// Gets a reference to the underlying value in this cursor.
 119     ///
 120     /// # Examples
 121     ///
 122     /// ```
 123     /// use std::io::Cursor;
 124     ///
 125     /// let buff = Cursor::new(Vec::new());
 126     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 127     /// # force_inference(&buff);
 128     ///
 129     /// let reference = buff.get_ref();
 130     /// ```
 131     #[stable(feature = "rust1", since = "1.0.0")]
 132     pub fn get_ref(&self) -> &T { &self.inner }
 133
 134     /// Gets a mutable reference to the underlying value in this cursor.
 135     ///
 136     /// Care should be taken to avoid modifying the internal I/O state of the
 137     /// underlying value as it may corrupt this cursor's position.
 138     ///
 139     /// # Examples
 140     ///
 141     /// ```
 142     /// use std::io::Cursor;
 143     ///
 144     /// let mut buff = Cursor::new(Vec::new());
 145     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 146     /// # force_inference(&buff);
 147     ///
 148     /// let reference = buff.get_mut();
 149     /// ```
 150     #[stable(feature = "rust1", since = "1.0.0")]
 151     pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
 152
 153     /// Returns the current position of this cursor.
 154     ///
 155     /// # Examples
 156     ///
 157     /// ```
 158     /// use std::io::Cursor;
 159     /// use std::io::prelude::*;
 160     /// use std::io::SeekFrom;
 161     ///
 162     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 163     ///
 164     /// assert_eq!(buff.position(), 0);
 165     ///
 166     /// buff.seek(SeekFrom::Current(2)).unwrap();
 167     /// assert_eq!(buff.position(), 2);
 168     ///
 169     /// buff.seek(SeekFrom::Current(-1)).unwrap();
 170     /// assert_eq!(buff.position(), 1);
 171     /// ```
 172     #[stable(feature = "rust1", since = "1.0.0")]
 173     pub fn position(&self) -> u64 { self.pos }
 174
 175     /// Sets the position of this cursor.
 176     ///
 177     /// # Examples
 178     ///
 179     /// ```
 180     /// use std::io::Cursor;
 181     ///
 182     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 183     ///
 184     /// assert_eq!(buff.position(), 0);
 185     ///
 186     /// buff.set_position(2);
 187     /// assert_eq!(buff.position(), 2);
 188     ///
 189     /// buff.set_position(4);
 190     /// assert_eq!(buff.position(), 4);
 191     /// ```
 192     #[stable(feature = "rust1", since = "1.0.0")]
 193     pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
 194 }
 195
 196 #[stable(feature = "rust1", since = "1.0.0")]
 197 impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
 198     fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
 199         let (base_pos, offset) = match style {
 200             SeekFrom::Start(n) => { self.pos = n; return Ok(n); }
 201             SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
 202             SeekFrom::Current(n) => (self.pos, n),
 203         };
 204         let new_pos = if offset >= 0 {
 205             base_pos.checked_add(offset as u64)
 206         } else {
 207             base_pos.checked_sub((offset.wrapping_neg()) as u64)
 208         };
 209         match new_pos {
 210             Some(n) => {self.pos = n; Ok(self.pos)}
 211             None => Err(Error::new(ErrorKind::InvalidInput,
 212                            "invalid seek to a negative or overflowing position"))
 213         }
 214     }
 215
 216     fn stream_len(&mut self) -> io::Result<u64> {
 217         Ok(self.inner.as_ref().len() as u64)
 218     }
 219
 220     fn stream_position(&mut self) -> io::Result<u64> {
 221         Ok(self.pos)
 222     }
 223 }
 224
 225 #[stable(feature = "rust1", since = "1.0.0")]
 226 impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
 227     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 228         let n = Read::read(&mut self.fill_buf()?, buf)?;
 229         self.pos += n as u64;
 230         Ok(n)
 231     }
 232
 233     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
 234         let mut nread = 0;
 235         for buf in bufs {
 236             let n = self.read(buf)?;
 237             nread += n;
 238             if n < buf.len() {
 239                 break;
 240             }
 241         }
 242         Ok(nread)
 243     }
 244
 245     fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
 246         let n = buf.len();
 247         Read::read_exact(&mut self.fill_buf()?, buf)?;
 248         self.pos += n as u64;
 249         Ok(())
 250     }
 251
 252     #[inline]
 253     unsafe fn initializer(&self) -> Initializer {
 254         Initializer::nop()
 255     }
 256 }
 257
 258 #[stable(feature = "rust1", since = "1.0.0")]
 259 impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
 260     fn fill_buf(&mut self) -> io::Result<&[u8]> {
 261         let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
 262         Ok(&self.inner.as_ref()[(amt as usize)..])
 263     }
 264     fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
 265 }
 266
 267 // Non-resizing write implementation
 268 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
 269     let pos = cmp::min(*pos_mut, slice.len() as u64);
 270     let amt = (&mut slice[(pos as usize)..]).write(buf)?;
 271     *pos_mut += amt as u64;
 272     Ok(amt)
 273 }
 274
 275 fn slice_write_vectored(
 276     pos_mut: &mut u64,
 277     slice: &mut [u8],
 278     bufs: &[IoSlice<'_>],
 279 ) -> io::Result<usize>
 280 {
 281     let mut nwritten = 0;
 282     for buf in bufs {
 283         let n = slice_write(pos_mut, slice, buf)?;
 284         nwritten += n;
 285         if n < buf.len() {
 286             break;
 287         }
 288     }
 289     Ok(nwritten)
 290 }
 291
 292 // Resizing write implementation
 293 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
 294     let pos: usize = (*pos_mut).try_into().map_err(|_| {
 295         Error::new(ErrorKind::InvalidInput,
 296                     "cursor position exceeds maximum possible vector length")
 297     })?;
 298     // Make sure the internal buffer is as least as big as where we
 299     // currently are
 300     let len = vec.len();
 301     if len < pos {
 302         // use `resize` so that the zero filling is as efficient as possible
 303         vec.resize(pos, 0);
 304     }
 305     // Figure out what bytes will be used to overwrite what's currently
 306     // there (left), and what will be appended on the end (right)
 307     {
 308         let space = vec.len() - pos;
 309         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
 310         vec[pos..pos + left.len()].copy_from_slice(left);
 311         vec.extend_from_slice(right);
 312     }
 313
 314     // Bump us forward
 315     *pos_mut = (pos + buf.len()) as u64;
 316     Ok(buf.len())
 317 }
 318
 319 fn vec_write_vectored(
 320     pos_mut: &mut u64,
 321     vec: &mut Vec<u8>,
 322     bufs: &[IoSlice<'_>],
 323 ) -> io::Result<usize>
 324 {
 325     let mut nwritten = 0;
 326     for buf in bufs {
 327         nwritten += vec_write(pos_mut, vec, buf)?;
 328     }
 329     Ok(nwritten)
 330 }
 331
 332 #[stable(feature = "rust1", since = "1.0.0")]
 333 impl Write for Cursor<&mut [u8]> {
 334     #[inline]
 335     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 336         slice_write(&mut self.pos, self.inner, buf)
 337     }
 338
 339     #[inline]
 340     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 341         slice_write_vectored(&mut self.pos, self.inner, bufs)
 342     }
 343
 344     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 345 }
 346
 347 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
 348 impl Write for Cursor<&mut Vec<u8>> {
 349     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 350         vec_write(&mut self.pos, self.inner, buf)
 351     }
 352
 353     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 354         vec_write_vectored(&mut self.pos, self.inner, bufs)
 355     }
 356
 357     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 358 }
 359
 360 #[stable(feature = "rust1", since = "1.0.0")]
 361 impl Write for Cursor<Vec<u8>> {
 362     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 363         vec_write(&mut self.pos, &mut self.inner, buf)
 364     }
 365
 366     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 367         vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
 368     }
 369
 370     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 371 }
 372
 373 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 374 impl Write for Cursor<Box<[u8]>> {
 375     #[inline]
 376     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 377         slice_write(&mut self.pos, &mut self.inner, buf)
 378     }
 379
 380     #[inline]
 381     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 382         slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
 383     }
 384
 385     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 386 }
 387
 388 #[cfg(test)]
 389 mod tests {
 390     use crate::io::prelude::*;
 391     use crate::io::{Cursor, SeekFrom, IoSlice, IoSliceMut};
 392
 393     #[test]
 394     fn test_vec_writer() {
 395         let mut writer = Vec::new();
 396         assert_eq!(writer.write(&[0]).unwrap(), 1);
 397         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 398         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 399         assert_eq!(writer.write_vectored(
 400             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 401         ).unwrap(), 3);
 402         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 403         assert_eq!(writer, b);
 404     }
 405
 406     #[test]
 407     fn test_mem_writer() {
 408         let mut writer = Cursor::new(Vec::new());
 409         assert_eq!(writer.write(&[0]).unwrap(), 1);
 410         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 411         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 412         assert_eq!(writer.write_vectored(
 413             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 414         ).unwrap(), 3);
 415         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 416         assert_eq!(&writer.get_ref()[..], b);
 417     }
 418
 419     #[test]
 420     fn test_mem_mut_writer() {
 421         let mut vec = Vec::new();
 422         let mut writer = Cursor::new(&mut vec);
 423         assert_eq!(writer.write(&[0]).unwrap(), 1);
 424         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 425         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 426         assert_eq!(writer.write_vectored(
 427             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 428         ).unwrap(), 3);
 429         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 430         assert_eq!(&writer.get_ref()[..], b);
 431     }
 432
 433     #[test]
 434     fn test_box_slice_writer() {
 435         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 436         assert_eq!(writer.position(), 0);
 437         assert_eq!(writer.write(&[0]).unwrap(), 1);
 438         assert_eq!(writer.position(), 1);
 439         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 440         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 441         assert_eq!(writer.position(), 8);
 442         assert_eq!(writer.write(&[]).unwrap(), 0);
 443         assert_eq!(writer.position(), 8);
 444
 445         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 446         assert_eq!(writer.write(&[10]).unwrap(), 0);
 447         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 448         assert_eq!(&**writer.get_ref(), b);
 449     }
 450
 451     #[test]
 452     fn test_box_slice_writer_vectored() {
 453         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 454         assert_eq!(writer.position(), 0);
 455         assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 456         assert_eq!(writer.position(), 1);
 457         assert_eq!(
 458             writer.write_vectored(&[
 459                 IoSlice::new(&[1, 2, 3]),
 460                 IoSlice::new(&[4, 5, 6, 7]),
 461             ]).unwrap(),
 462             7,
 463         );
 464         assert_eq!(writer.position(), 8);
 465         assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 466         assert_eq!(writer.position(), 8);
 467
 468         assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 469         assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 470         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 471         assert_eq!(&**writer.get_ref(), b);
 472     }
 473
 474     #[test]
 475     fn test_buf_writer() {
 476         let mut buf = [0 as u8; 9];
 477         {
 478             let mut writer = Cursor::new(&mut buf[..]);
 479             assert_eq!(writer.position(), 0);
 480             assert_eq!(writer.write(&[0]).unwrap(), 1);
 481             assert_eq!(writer.position(), 1);
 482             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 483             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 484             assert_eq!(writer.position(), 8);
 485             assert_eq!(writer.write(&[]).unwrap(), 0);
 486             assert_eq!(writer.position(), 8);
 487
 488             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 489             assert_eq!(writer.write(&[10]).unwrap(), 0);
 490         }
 491         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 492         assert_eq!(buf, b);
 493     }
 494
 495     #[test]
 496     fn test_buf_writer_vectored() {
 497         let mut buf = [0 as u8; 9];
 498         {
 499             let mut writer = Cursor::new(&mut buf[..]);
 500             assert_eq!(writer.position(), 0);
 501             assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 502             assert_eq!(writer.position(), 1);
 503             assert_eq!(
 504                 writer.write_vectored(
 505                     &[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],
 506                 ).unwrap(),
 507                 7,
 508             );
 509             assert_eq!(writer.position(), 8);
 510             assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 511             assert_eq!(writer.position(), 8);
 512
 513             assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 514             assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 515         }
 516         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 517         assert_eq!(buf, b);
 518     }
 519
 520     #[test]
 521     fn test_buf_writer_seek() {
 522         let mut buf = [0 as u8; 8];
 523         {
 524             let mut writer = Cursor::new(&mut buf[..]);
 525             assert_eq!(writer.position(), 0);
 526             assert_eq!(writer.write(&[1]).unwrap(), 1);
 527             assert_eq!(writer.position(), 1);
 528
 529             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 530             assert_eq!(writer.position(), 2);
 531             assert_eq!(writer.write(&[2]).unwrap(), 1);
 532             assert_eq!(writer.position(), 3);
 533
 534             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 535             assert_eq!(writer.position(), 1);
 536             assert_eq!(writer.write(&[3]).unwrap(), 1);
 537             assert_eq!(writer.position(), 2);
 538
 539             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 540             assert_eq!(writer.position(), 7);
 541             assert_eq!(writer.write(&[4]).unwrap(), 1);
 542             assert_eq!(writer.position(), 8);
 543
 544         }
 545         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 546         assert_eq!(buf, b);
 547     }
 548
 549     #[test]
 550     fn test_buf_writer_error() {
 551         let mut buf = [0 as u8; 2];
 552         let mut writer = Cursor::new(&mut buf[..]);
 553         assert_eq!(writer.write(&[0]).unwrap(), 1);
 554         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 555         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 556     }
 557
 558     #[test]
 559     fn test_mem_reader() {
 560         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 561         let mut buf = [];
 562         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 563         assert_eq!(reader.position(), 0);
 564         let mut buf = [0];
 565         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 566         assert_eq!(reader.position(), 1);
 567         let b: &[_] = &[0];
 568         assert_eq!(buf, b);
 569         let mut buf = [0; 4];
 570         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 571         assert_eq!(reader.position(), 5);
 572         let b: &[_] = &[1, 2, 3, 4];
 573         assert_eq!(buf, b);
 574         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 575         let b: &[_] = &[5, 6, 7];
 576         assert_eq!(&buf[..3], b);
 577         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 578     }
 579
 580     #[test]
 581     fn test_mem_reader_vectored() {
 582         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 583         let mut buf = [];
 584         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 585         assert_eq!(reader.position(), 0);
 586         let mut buf = [0];
 587         assert_eq!(
 588             reader.read_vectored(&mut [
 589                 IoSliceMut::new(&mut []),
 590                 IoSliceMut::new(&mut buf),
 591             ]).unwrap(),
 592             1,
 593         );
 594         assert_eq!(reader.position(), 1);
 595         let b: &[_] = &[0];
 596         assert_eq!(buf, b);
 597         let mut buf1 = [0; 4];
 598         let mut buf2 = [0; 4];
 599         assert_eq!(
 600             reader.read_vectored(&mut [
 601                 IoSliceMut::new(&mut buf1),
 602                 IoSliceMut::new(&mut buf2),
 603             ]).unwrap(),
 604             7,
 605         );
 606         let b1: &[_] = &[1, 2, 3, 4];
 607         let b2: &[_] = &[5, 6, 7];
 608         assert_eq!(buf1, b1);
 609         assert_eq!(&buf2[..3], b2);
 610         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 611     }
 612
 613     #[test]
 614     fn test_boxed_slice_reader() {
 615         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 616         let mut buf = [];
 617         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 618         assert_eq!(reader.position(), 0);
 619         let mut buf = [0];
 620         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 621         assert_eq!(reader.position(), 1);
 622         let b: &[_] = &[0];
 623         assert_eq!(buf, b);
 624         let mut buf = [0; 4];
 625         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 626         assert_eq!(reader.position(), 5);
 627         let b: &[_] = &[1, 2, 3, 4];
 628         assert_eq!(buf, b);
 629         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 630         let b: &[_] = &[5, 6, 7];
 631         assert_eq!(&buf[..3], b);
 632         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 633     }
 634
 635     #[test]
 636     fn test_boxed_slice_reader_vectored() {
 637         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 638         let mut buf = [];
 639         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 640         assert_eq!(reader.position(), 0);
 641         let mut buf = [0];
 642         assert_eq!(
 643             reader.read_vectored(&mut [
 644                 IoSliceMut::new(&mut []),
 645                 IoSliceMut::new(&mut buf),
 646             ]).unwrap(),
 647             1,
 648         );
 649         assert_eq!(reader.position(), 1);
 650         let b: &[_] = &[0];
 651         assert_eq!(buf, b);
 652         let mut buf1 = [0; 4];
 653         let mut buf2 = [0; 4];
 654         assert_eq!(
 655             reader.read_vectored(
 656                 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
 657             ).unwrap(),
 658             7,
 659         );
 660         let b1: &[_] = &[1, 2, 3, 4];
 661         let b2: &[_] = &[5, 6, 7];
 662         assert_eq!(buf1, b1);
 663         assert_eq!(&buf2[..3], b2);
 664         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 665     }
 666
 667     #[test]
 668     fn read_to_end() {
 669         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 670         let mut v = Vec::new();
 671         reader.read_to_end(&mut v).unwrap();
 672         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 673     }
 674
 675     #[test]
 676     fn test_slice_reader() {
 677         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 678         let reader = &mut &in_buf[..];
 679         let mut buf = [];
 680         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 681         let mut buf = [0];
 682         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 683         assert_eq!(reader.len(), 7);
 684         let b: &[_] = &[0];
 685         assert_eq!(&buf[..], b);
 686         let mut buf = [0; 4];
 687         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 688         assert_eq!(reader.len(), 3);
 689         let b: &[_] = &[1, 2, 3, 4];
 690         assert_eq!(&buf[..], b);
 691         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 692         let b: &[_] = &[5, 6, 7];
 693         assert_eq!(&buf[..3], b);
 694         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 695     }
 696
 697     #[test]
 698     fn test_slice_reader_vectored() {
 699         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 700         let reader = &mut &in_buf[..];
 701         let mut buf = [];
 702         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 703         let mut buf = [0];
 704         assert_eq!(
 705             reader.read_vectored(&mut [
 706                 IoSliceMut::new(&mut []),
 707                 IoSliceMut::new(&mut buf),
 708             ]).unwrap(),
 709             1,
 710         );
 711         assert_eq!(reader.len(), 7);
 712         let b: &[_] = &[0];
 713         assert_eq!(buf, b);
 714         let mut buf1 = [0; 4];
 715         let mut buf2 = [0; 4];
 716         assert_eq!(
 717             reader.read_vectored(
 718                 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
 719             ).unwrap(),
 720             7,
 721         );
 722         let b1: &[_] = &[1, 2, 3, 4];
 723         let b2: &[_] = &[5, 6, 7];
 724         assert_eq!(buf1, b1);
 725         assert_eq!(&buf2[..3], b2);
 726         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 727     }
 728
 729     #[test]
 730     fn test_read_exact() {
 731         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 732         let reader = &mut &in_buf[..];
 733         let mut buf = [];
 734         assert!(reader.read_exact(&mut buf).is_ok());
 735         let mut buf = [8];
 736         assert!(reader.read_exact(&mut buf).is_ok());
 737         assert_eq!(buf[0], 0);
 738         assert_eq!(reader.len(), 7);
 739         let mut buf = [0, 0, 0, 0, 0, 0, 0];
 740         assert!(reader.read_exact(&mut buf).is_ok());
 741         assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
 742         assert_eq!(reader.len(), 0);
 743         let mut buf = [0];
 744         assert!(reader.read_exact(&mut buf).is_err());
 745     }
 746
 747     #[test]
 748     fn test_buf_reader() {
 749         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 750         let mut reader = Cursor::new(&in_buf[..]);
 751         let mut buf = [];
 752         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 753         assert_eq!(reader.position(), 0);
 754         let mut buf = [0];
 755         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 756         assert_eq!(reader.position(), 1);
 757         let b: &[_] = &[0];
 758         assert_eq!(buf, b);
 759         let mut buf = [0; 4];
 760         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 761         assert_eq!(reader.position(), 5);
 762         let b: &[_] = &[1, 2, 3, 4];
 763         assert_eq!(buf, b);
 764         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 765         let b: &[_] = &[5, 6, 7];
 766         assert_eq!(&buf[..3], b);
 767         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 768     }
 769
 770     #[test]
 771     fn seek_past_end() {
 772         let buf = [0xff];
 773         let mut r = Cursor::new(&buf[..]);
 774         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 775         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 776
 777         let mut r = Cursor::new(vec![10]);
 778         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 779         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 780
 781         let mut buf = [0];
 782         let mut r = Cursor::new(&mut buf[..]);
 783         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 784         assert_eq!(r.write(&[3]).unwrap(), 0);
 785
 786         let mut r = Cursor::new(vec![10].into_boxed_slice());
 787         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 788         assert_eq!(r.write(&[3]).unwrap(), 0);
 789     }
 790
 791     #[test]
 792     fn seek_past_i64() {
 793         let buf = [0xff];
 794         let mut r = Cursor::new(&buf[..]);
 795         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 796         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 797         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 798         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 799         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 800         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 801
 802         let mut r = Cursor::new(vec![10]);
 803         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 804         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 805         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 806         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 807         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 808         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 809
 810         let mut buf = [0];
 811         let mut r = Cursor::new(&mut buf[..]);
 812         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 813         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 814         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 815         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 816         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 817         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 818
 819         let mut r = Cursor::new(vec![10].into_boxed_slice());
 820         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 821         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 822         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 823         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 824         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 825         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 826     }
 827
 828     #[test]
 829     fn seek_before_0() {
 830         let buf = [0xff];
 831         let mut r = Cursor::new(&buf[..]);
 832         assert!(r.seek(SeekFrom::End(-2)).is_err());
 833
 834         let mut r = Cursor::new(vec![10]);
 835         assert!(r.seek(SeekFrom::End(-2)).is_err());
 836
 837         let mut buf = [0];
 838         let mut r = Cursor::new(&mut buf[..]);
 839         assert!(r.seek(SeekFrom::End(-2)).is_err());
 840
 841         let mut r = Cursor::new(vec![10].into_boxed_slice());
 842         assert!(r.seek(SeekFrom::End(-2)).is_err());
 843     }
 844
 845     #[test]
 846     fn test_seekable_mem_writer() {
 847         let mut writer = Cursor::new(Vec::<u8>::new());
 848         assert_eq!(writer.position(), 0);
 849         assert_eq!(writer.write(&[0]).unwrap(), 1);
 850         assert_eq!(writer.position(), 1);
 851         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 852         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 853         assert_eq!(writer.position(), 8);
 854         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 855         assert_eq!(&writer.get_ref()[..], b);
 856
 857         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 858         assert_eq!(writer.position(), 0);
 859         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 860         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 861         assert_eq!(&writer.get_ref()[..], b);
 862
 863         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 864         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 865         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 866         assert_eq!(&writer.get_ref()[..], b);
 867
 868         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 869         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 870         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 871         assert_eq!(&writer.get_ref()[..], b);
 872
 873         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 874         assert_eq!(writer.write(&[1]).unwrap(), 1);
 875         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 876         assert_eq!(&writer.get_ref()[..], b);
 877     }
 878
 879     #[test]
 880     fn vec_seek_past_end() {
 881         let mut r = Cursor::new(Vec::new());
 882         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 883         assert_eq!(r.write(&[3]).unwrap(), 1);
 884     }
 885
 886     #[test]
 887     fn vec_seek_before_0() {
 888         let mut r = Cursor::new(Vec::new());
 889         assert!(r.seek(SeekFrom::End(-2)).is_err());
 890     }
 891
 892     #[test]
 893     #[cfg(target_pointer_width = "32")]
 894     fn vec_seek_and_write_past_usize_max() {
 895         let mut c = Cursor::new(Vec::new());
 896         c.set_position(<usize>::max_value() as u64 + 1);
 897         assert!(c.write_all(&[1, 2, 3]).is_err());
 898     }
 899 }