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, Default)]
  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 #[inline]
 269 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
 270     let pos = cmp::min(*pos_mut, slice.len() as u64);
 271     let amt = (&mut slice[(pos as usize)..]).write(buf)?;
 272     *pos_mut += amt as u64;
 273     Ok(amt)
 274 }
 275
 276 #[inline]
 277 fn slice_write_vectored(
 278     pos_mut: &mut u64,
 279     slice: &mut [u8],
 280     bufs: &[IoSlice<'_>],
 281 ) -> io::Result<usize>
 282 {
 283     let mut nwritten = 0;
 284     for buf in bufs {
 285         let n = slice_write(pos_mut, slice, buf)?;
 286         nwritten += n;
 287         if n < buf.len() {
 288             break;
 289         }
 290     }
 291     Ok(nwritten)
 292 }
 293
 294 // Resizing write implementation
 295 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
 296     let pos: usize = (*pos_mut).try_into().map_err(|_| {
 297         Error::new(ErrorKind::InvalidInput,
 298                     "cursor position exceeds maximum possible vector length")
 299     })?;
 300     // Make sure the internal buffer is as least as big as where we
 301     // currently are
 302     let len = vec.len();
 303     if len < pos {
 304         // use `resize` so that the zero filling is as efficient as possible
 305         vec.resize(pos, 0);
 306     }
 307     // Figure out what bytes will be used to overwrite what's currently
 308     // there (left), and what will be appended on the end (right)
 309     {
 310         let space = vec.len() - pos;
 311         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
 312         vec[pos..pos + left.len()].copy_from_slice(left);
 313         vec.extend_from_slice(right);
 314     }
 315
 316     // Bump us forward
 317     *pos_mut = (pos + buf.len()) as u64;
 318     Ok(buf.len())
 319 }
 320
 321 fn vec_write_vectored(
 322     pos_mut: &mut u64,
 323     vec: &mut Vec<u8>,
 324     bufs: &[IoSlice<'_>],
 325 ) -> io::Result<usize>
 326 {
 327     let mut nwritten = 0;
 328     for buf in bufs {
 329         nwritten += vec_write(pos_mut, vec, buf)?;
 330     }
 331     Ok(nwritten)
 332 }
 333
 334 #[stable(feature = "rust1", since = "1.0.0")]
 335 impl Write for Cursor<&mut [u8]> {
 336     #[inline]
 337     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 338         slice_write(&mut self.pos, self.inner, buf)
 339     }
 340
 341     #[inline]
 342     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 343         slice_write_vectored(&mut self.pos, self.inner, bufs)
 344     }
 345
 346     #[inline]
 347     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 348 }
 349
 350 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
 351 impl Write for Cursor<&mut Vec<u8>> {
 352     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 353         vec_write(&mut self.pos, self.inner, buf)
 354     }
 355
 356     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 357         vec_write_vectored(&mut self.pos, self.inner, bufs)
 358     }
 359
 360     #[inline]
 361     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 362 }
 363
 364 #[stable(feature = "rust1", since = "1.0.0")]
 365 impl Write for Cursor<Vec<u8>> {
 366     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 367         vec_write(&mut self.pos, &mut self.inner, buf)
 368     }
 369
 370     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 371         vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
 372     }
 373
 374     #[inline]
 375     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 376 }
 377
 378 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 379 impl Write for Cursor<Box<[u8]>> {
 380     #[inline]
 381     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 382         slice_write(&mut self.pos, &mut self.inner, buf)
 383     }
 384
 385     #[inline]
 386     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 387         slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
 388     }
 389
 390     #[inline]
 391     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 392 }
 393
 394 #[cfg(test)]
 395 mod tests {
 396     use crate::io::prelude::*;
 397     use crate::io::{Cursor, SeekFrom, IoSlice, IoSliceMut};
 398
 399     #[test]
 400     fn test_vec_writer() {
 401         let mut writer = Vec::new();
 402         assert_eq!(writer.write(&[0]).unwrap(), 1);
 403         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 404         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 405         assert_eq!(writer.write_vectored(
 406             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 407         ).unwrap(), 3);
 408         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 409         assert_eq!(writer, b);
 410     }
 411
 412     #[test]
 413     fn test_mem_writer() {
 414         let mut writer = Cursor::new(Vec::new());
 415         assert_eq!(writer.write(&[0]).unwrap(), 1);
 416         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 417         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 418         assert_eq!(writer.write_vectored(
 419             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 420         ).unwrap(), 3);
 421         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 422         assert_eq!(&writer.get_ref()[..], b);
 423     }
 424
 425     #[test]
 426     fn test_mem_mut_writer() {
 427         let mut vec = Vec::new();
 428         let mut writer = Cursor::new(&mut vec);
 429         assert_eq!(writer.write(&[0]).unwrap(), 1);
 430         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 431         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 432         assert_eq!(writer.write_vectored(
 433             &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
 434         ).unwrap(), 3);
 435         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 436         assert_eq!(&writer.get_ref()[..], b);
 437     }
 438
 439     #[test]
 440     fn test_box_slice_writer() {
 441         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 442         assert_eq!(writer.position(), 0);
 443         assert_eq!(writer.write(&[0]).unwrap(), 1);
 444         assert_eq!(writer.position(), 1);
 445         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 446         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 447         assert_eq!(writer.position(), 8);
 448         assert_eq!(writer.write(&[]).unwrap(), 0);
 449         assert_eq!(writer.position(), 8);
 450
 451         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 452         assert_eq!(writer.write(&[10]).unwrap(), 0);
 453         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 454         assert_eq!(&**writer.get_ref(), b);
 455     }
 456
 457     #[test]
 458     fn test_box_slice_writer_vectored() {
 459         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 460         assert_eq!(writer.position(), 0);
 461         assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 462         assert_eq!(writer.position(), 1);
 463         assert_eq!(
 464             writer.write_vectored(&[
 465                 IoSlice::new(&[1, 2, 3]),
 466                 IoSlice::new(&[4, 5, 6, 7]),
 467             ]).unwrap(),
 468             7,
 469         );
 470         assert_eq!(writer.position(), 8);
 471         assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 472         assert_eq!(writer.position(), 8);
 473
 474         assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 475         assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 476         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 477         assert_eq!(&**writer.get_ref(), b);
 478     }
 479
 480     #[test]
 481     fn test_buf_writer() {
 482         let mut buf = [0 as u8; 9];
 483         {
 484             let mut writer = Cursor::new(&mut buf[..]);
 485             assert_eq!(writer.position(), 0);
 486             assert_eq!(writer.write(&[0]).unwrap(), 1);
 487             assert_eq!(writer.position(), 1);
 488             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 489             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 490             assert_eq!(writer.position(), 8);
 491             assert_eq!(writer.write(&[]).unwrap(), 0);
 492             assert_eq!(writer.position(), 8);
 493
 494             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 495             assert_eq!(writer.write(&[10]).unwrap(), 0);
 496         }
 497         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 498         assert_eq!(buf, b);
 499     }
 500
 501     #[test]
 502     fn test_buf_writer_vectored() {
 503         let mut buf = [0 as u8; 9];
 504         {
 505             let mut writer = Cursor::new(&mut buf[..]);
 506             assert_eq!(writer.position(), 0);
 507             assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 508             assert_eq!(writer.position(), 1);
 509             assert_eq!(
 510                 writer.write_vectored(
 511                     &[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],
 512                 ).unwrap(),
 513                 7,
 514             );
 515             assert_eq!(writer.position(), 8);
 516             assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 517             assert_eq!(writer.position(), 8);
 518
 519             assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 520             assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 521         }
 522         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 523         assert_eq!(buf, b);
 524     }
 525
 526     #[test]
 527     fn test_buf_writer_seek() {
 528         let mut buf = [0 as u8; 8];
 529         {
 530             let mut writer = Cursor::new(&mut buf[..]);
 531             assert_eq!(writer.position(), 0);
 532             assert_eq!(writer.write(&[1]).unwrap(), 1);
 533             assert_eq!(writer.position(), 1);
 534
 535             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 536             assert_eq!(writer.position(), 2);
 537             assert_eq!(writer.write(&[2]).unwrap(), 1);
 538             assert_eq!(writer.position(), 3);
 539
 540             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 541             assert_eq!(writer.position(), 1);
 542             assert_eq!(writer.write(&[3]).unwrap(), 1);
 543             assert_eq!(writer.position(), 2);
 544
 545             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 546             assert_eq!(writer.position(), 7);
 547             assert_eq!(writer.write(&[4]).unwrap(), 1);
 548             assert_eq!(writer.position(), 8);
 549
 550         }
 551         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 552         assert_eq!(buf, b);
 553     }
 554
 555     #[test]
 556     fn test_buf_writer_error() {
 557         let mut buf = [0 as u8; 2];
 558         let mut writer = Cursor::new(&mut buf[..]);
 559         assert_eq!(writer.write(&[0]).unwrap(), 1);
 560         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 561         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 562     }
 563
 564     #[test]
 565     fn test_mem_reader() {
 566         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 567         let mut buf = [];
 568         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 569         assert_eq!(reader.position(), 0);
 570         let mut buf = [0];
 571         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 572         assert_eq!(reader.position(), 1);
 573         let b: &[_] = &[0];
 574         assert_eq!(buf, b);
 575         let mut buf = [0; 4];
 576         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 577         assert_eq!(reader.position(), 5);
 578         let b: &[_] = &[1, 2, 3, 4];
 579         assert_eq!(buf, b);
 580         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 581         let b: &[_] = &[5, 6, 7];
 582         assert_eq!(&buf[..3], b);
 583         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 584     }
 585
 586     #[test]
 587     fn test_mem_reader_vectored() {
 588         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 589         let mut buf = [];
 590         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 591         assert_eq!(reader.position(), 0);
 592         let mut buf = [0];
 593         assert_eq!(
 594             reader.read_vectored(&mut [
 595                 IoSliceMut::new(&mut []),
 596                 IoSliceMut::new(&mut buf),
 597             ]).unwrap(),
 598             1,
 599         );
 600         assert_eq!(reader.position(), 1);
 601         let b: &[_] = &[0];
 602         assert_eq!(buf, b);
 603         let mut buf1 = [0; 4];
 604         let mut buf2 = [0; 4];
 605         assert_eq!(
 606             reader.read_vectored(&mut [
 607                 IoSliceMut::new(&mut buf1),
 608                 IoSliceMut::new(&mut buf2),
 609             ]).unwrap(),
 610             7,
 611         );
 612         let b1: &[_] = &[1, 2, 3, 4];
 613         let b2: &[_] = &[5, 6, 7];
 614         assert_eq!(buf1, b1);
 615         assert_eq!(&buf2[..3], b2);
 616         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 617     }
 618
 619     #[test]
 620     fn test_boxed_slice_reader() {
 621         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 622         let mut buf = [];
 623         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 624         assert_eq!(reader.position(), 0);
 625         let mut buf = [0];
 626         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 627         assert_eq!(reader.position(), 1);
 628         let b: &[_] = &[0];
 629         assert_eq!(buf, b);
 630         let mut buf = [0; 4];
 631         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 632         assert_eq!(reader.position(), 5);
 633         let b: &[_] = &[1, 2, 3, 4];
 634         assert_eq!(buf, b);
 635         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 636         let b: &[_] = &[5, 6, 7];
 637         assert_eq!(&buf[..3], b);
 638         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 639     }
 640
 641     #[test]
 642     fn test_boxed_slice_reader_vectored() {
 643         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 644         let mut buf = [];
 645         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 646         assert_eq!(reader.position(), 0);
 647         let mut buf = [0];
 648         assert_eq!(
 649             reader.read_vectored(&mut [
 650                 IoSliceMut::new(&mut []),
 651                 IoSliceMut::new(&mut buf),
 652             ]).unwrap(),
 653             1,
 654         );
 655         assert_eq!(reader.position(), 1);
 656         let b: &[_] = &[0];
 657         assert_eq!(buf, b);
 658         let mut buf1 = [0; 4];
 659         let mut buf2 = [0; 4];
 660         assert_eq!(
 661             reader.read_vectored(
 662                 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
 663             ).unwrap(),
 664             7,
 665         );
 666         let b1: &[_] = &[1, 2, 3, 4];
 667         let b2: &[_] = &[5, 6, 7];
 668         assert_eq!(buf1, b1);
 669         assert_eq!(&buf2[..3], b2);
 670         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 671     }
 672
 673     #[test]
 674     fn read_to_end() {
 675         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 676         let mut v = Vec::new();
 677         reader.read_to_end(&mut v).unwrap();
 678         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 679     }
 680
 681     #[test]
 682     fn test_slice_reader() {
 683         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 684         let reader = &mut &in_buf[..];
 685         let mut buf = [];
 686         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 687         let mut buf = [0];
 688         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 689         assert_eq!(reader.len(), 7);
 690         let b: &[_] = &[0];
 691         assert_eq!(&buf[..], b);
 692         let mut buf = [0; 4];
 693         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 694         assert_eq!(reader.len(), 3);
 695         let b: &[_] = &[1, 2, 3, 4];
 696         assert_eq!(&buf[..], b);
 697         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 698         let b: &[_] = &[5, 6, 7];
 699         assert_eq!(&buf[..3], b);
 700         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 701     }
 702
 703     #[test]
 704     fn test_slice_reader_vectored() {
 705         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 706         let reader = &mut &in_buf[..];
 707         let mut buf = [];
 708         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 709         let mut buf = [0];
 710         assert_eq!(
 711             reader.read_vectored(&mut [
 712                 IoSliceMut::new(&mut []),
 713                 IoSliceMut::new(&mut buf),
 714             ]).unwrap(),
 715             1,
 716         );
 717         assert_eq!(reader.len(), 7);
 718         let b: &[_] = &[0];
 719         assert_eq!(buf, b);
 720         let mut buf1 = [0; 4];
 721         let mut buf2 = [0; 4];
 722         assert_eq!(
 723             reader.read_vectored(
 724                 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
 725             ).unwrap(),
 726             7,
 727         );
 728         let b1: &[_] = &[1, 2, 3, 4];
 729         let b2: &[_] = &[5, 6, 7];
 730         assert_eq!(buf1, b1);
 731         assert_eq!(&buf2[..3], b2);
 732         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 733     }
 734
 735     #[test]
 736     fn test_read_exact() {
 737         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 738         let reader = &mut &in_buf[..];
 739         let mut buf = [];
 740         assert!(reader.read_exact(&mut buf).is_ok());
 741         let mut buf = [8];
 742         assert!(reader.read_exact(&mut buf).is_ok());
 743         assert_eq!(buf[0], 0);
 744         assert_eq!(reader.len(), 7);
 745         let mut buf = [0, 0, 0, 0, 0, 0, 0];
 746         assert!(reader.read_exact(&mut buf).is_ok());
 747         assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
 748         assert_eq!(reader.len(), 0);
 749         let mut buf = [0];
 750         assert!(reader.read_exact(&mut buf).is_err());
 751     }
 752
 753     #[test]
 754     fn test_buf_reader() {
 755         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 756         let mut reader = Cursor::new(&in_buf[..]);
 757         let mut buf = [];
 758         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 759         assert_eq!(reader.position(), 0);
 760         let mut buf = [0];
 761         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 762         assert_eq!(reader.position(), 1);
 763         let b: &[_] = &[0];
 764         assert_eq!(buf, b);
 765         let mut buf = [0; 4];
 766         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 767         assert_eq!(reader.position(), 5);
 768         let b: &[_] = &[1, 2, 3, 4];
 769         assert_eq!(buf, b);
 770         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 771         let b: &[_] = &[5, 6, 7];
 772         assert_eq!(&buf[..3], b);
 773         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 774     }
 775
 776     #[test]
 777     fn seek_past_end() {
 778         let buf = [0xff];
 779         let mut r = Cursor::new(&buf[..]);
 780         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 781         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 782
 783         let mut r = Cursor::new(vec![10]);
 784         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 785         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 786
 787         let mut buf = [0];
 788         let mut r = Cursor::new(&mut buf[..]);
 789         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 790         assert_eq!(r.write(&[3]).unwrap(), 0);
 791
 792         let mut r = Cursor::new(vec![10].into_boxed_slice());
 793         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 794         assert_eq!(r.write(&[3]).unwrap(), 0);
 795     }
 796
 797     #[test]
 798     fn seek_past_i64() {
 799         let buf = [0xff];
 800         let mut r = Cursor::new(&buf[..]);
 801         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 802         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 803         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 804         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 805         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 806         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 807
 808         let mut r = Cursor::new(vec![10]);
 809         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 810         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 811         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 812         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 813         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 814         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 815
 816         let mut buf = [0];
 817         let mut r = Cursor::new(&mut buf[..]);
 818         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 819         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 820         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 821         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 822         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 823         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 824
 825         let mut r = Cursor::new(vec![10].into_boxed_slice());
 826         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 827         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 828         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 829         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 830         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 831         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 832     }
 833
 834     #[test]
 835     fn seek_before_0() {
 836         let buf = [0xff];
 837         let mut r = Cursor::new(&buf[..]);
 838         assert!(r.seek(SeekFrom::End(-2)).is_err());
 839
 840         let mut r = Cursor::new(vec![10]);
 841         assert!(r.seek(SeekFrom::End(-2)).is_err());
 842
 843         let mut buf = [0];
 844         let mut r = Cursor::new(&mut buf[..]);
 845         assert!(r.seek(SeekFrom::End(-2)).is_err());
 846
 847         let mut r = Cursor::new(vec![10].into_boxed_slice());
 848         assert!(r.seek(SeekFrom::End(-2)).is_err());
 849     }
 850
 851     #[test]
 852     fn test_seekable_mem_writer() {
 853         let mut writer = Cursor::new(Vec::<u8>::new());
 854         assert_eq!(writer.position(), 0);
 855         assert_eq!(writer.write(&[0]).unwrap(), 1);
 856         assert_eq!(writer.position(), 1);
 857         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 858         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 859         assert_eq!(writer.position(), 8);
 860         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 861         assert_eq!(&writer.get_ref()[..], b);
 862
 863         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 864         assert_eq!(writer.position(), 0);
 865         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 866         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 867         assert_eq!(&writer.get_ref()[..], b);
 868
 869         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 870         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 871         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 872         assert_eq!(&writer.get_ref()[..], b);
 873
 874         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 875         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 876         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 877         assert_eq!(&writer.get_ref()[..], b);
 878
 879         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 880         assert_eq!(writer.write(&[1]).unwrap(), 1);
 881         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 882         assert_eq!(&writer.get_ref()[..], b);
 883     }
 884
 885     #[test]
 886     fn vec_seek_past_end() {
 887         let mut r = Cursor::new(Vec::new());
 888         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 889         assert_eq!(r.write(&[3]).unwrap(), 1);
 890     }
 891
 892     #[test]
 893     fn vec_seek_before_0() {
 894         let mut r = Cursor::new(Vec::new());
 895         assert!(r.seek(SeekFrom::End(-2)).is_err());
 896     }
 897
 898     #[test]
 899     #[cfg(target_pointer_width = "32")]
 900     fn vec_seek_and_write_past_usize_max() {
 901         let mut c = Cursor::new(Vec::new());
 902         c.set_position(<usize>::max_value() as u64 + 1);
 903         assert!(c.write_all(&[1, 2, 3]).is_err());
 904     }
 905 }