src/libstd/io/cursor.rs

   1 use crate::io::prelude::*;
   2
   3 use crate::cmp;
   4 use crate::io::{self, Error, ErrorKind, Initializer, IoSlice, IoSliceMut, SeekFrom};
   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, Eq, PartialEq)]
  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 {
 117         self.inner
 118     }
 119
 120     /// Gets a reference to the underlying value in this cursor.
 121     ///
 122     /// # Examples
 123     ///
 124     /// ```
 125     /// use std::io::Cursor;
 126     ///
 127     /// let buff = Cursor::new(Vec::new());
 128     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 129     /// # force_inference(&buff);
 130     ///
 131     /// let reference = buff.get_ref();
 132     /// ```
 133     #[stable(feature = "rust1", since = "1.0.0")]
 134     pub fn get_ref(&self) -> &T {
 135         &self.inner
 136     }
 137
 138     /// Gets a mutable reference to the underlying value in this cursor.
 139     ///
 140     /// Care should be taken to avoid modifying the internal I/O state of the
 141     /// underlying value as it may corrupt this cursor's position.
 142     ///
 143     /// # Examples
 144     ///
 145     /// ```
 146     /// use std::io::Cursor;
 147     ///
 148     /// let mut buff = Cursor::new(Vec::new());
 149     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 150     /// # force_inference(&buff);
 151     ///
 152     /// let reference = buff.get_mut();
 153     /// ```
 154     #[stable(feature = "rust1", since = "1.0.0")]
 155     pub fn get_mut(&mut self) -> &mut T {
 156         &mut self.inner
 157     }
 158
 159     /// Returns the current position of this cursor.
 160     ///
 161     /// # Examples
 162     ///
 163     /// ```
 164     /// use std::io::Cursor;
 165     /// use std::io::prelude::*;
 166     /// use std::io::SeekFrom;
 167     ///
 168     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 169     ///
 170     /// assert_eq!(buff.position(), 0);
 171     ///
 172     /// buff.seek(SeekFrom::Current(2)).unwrap();
 173     /// assert_eq!(buff.position(), 2);
 174     ///
 175     /// buff.seek(SeekFrom::Current(-1)).unwrap();
 176     /// assert_eq!(buff.position(), 1);
 177     /// ```
 178     #[stable(feature = "rust1", since = "1.0.0")]
 179     pub fn position(&self) -> u64 {
 180         self.pos
 181     }
 182
 183     /// Sets the position of this cursor.
 184     ///
 185     /// # Examples
 186     ///
 187     /// ```
 188     /// use std::io::Cursor;
 189     ///
 190     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 191     ///
 192     /// assert_eq!(buff.position(), 0);
 193     ///
 194     /// buff.set_position(2);
 195     /// assert_eq!(buff.position(), 2);
 196     ///
 197     /// buff.set_position(4);
 198     /// assert_eq!(buff.position(), 4);
 199     /// ```
 200     #[stable(feature = "rust1", since = "1.0.0")]
 201     pub fn set_position(&mut self, pos: u64) {
 202         self.pos = pos;
 203     }
 204 }
 205
 206 #[stable(feature = "rust1", since = "1.0.0")]
 207 impl<T> io::Seek for Cursor<T>
 208 where
 209     T: AsRef<[u8]>,
 210 {
 211     fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
 212         let (base_pos, offset) = match style {
 213             SeekFrom::Start(n) => {
 214                 self.pos = n;
 215                 return Ok(n);
 216             }
 217             SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
 218             SeekFrom::Current(n) => (self.pos, n),
 219         };
 220         let new_pos = if offset >= 0 {
 221             base_pos.checked_add(offset as u64)
 222         } else {
 223             base_pos.checked_sub((offset.wrapping_neg()) as u64)
 224         };
 225         match new_pos {
 226             Some(n) => {
 227                 self.pos = n;
 228                 Ok(self.pos)
 229             }
 230             None => Err(Error::new(
 231                 ErrorKind::InvalidInput,
 232                 "invalid seek to a negative or overflowing position",
 233             )),
 234         }
 235     }
 236
 237     fn stream_len(&mut self) -> io::Result<u64> {
 238         Ok(self.inner.as_ref().len() as u64)
 239     }
 240
 241     fn stream_position(&mut self) -> io::Result<u64> {
 242         Ok(self.pos)
 243     }
 244 }
 245
 246 #[stable(feature = "rust1", since = "1.0.0")]
 247 impl<T> Read for Cursor<T>
 248 where
 249     T: AsRef<[u8]>,
 250 {
 251     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 252         let n = Read::read(&mut self.fill_buf()?, buf)?;
 253         self.pos += n as u64;
 254         Ok(n)
 255     }
 256
 257     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
 258         let mut nread = 0;
 259         for buf in bufs {
 260             let n = self.read(buf)?;
 261             nread += n;
 262             if n < buf.len() {
 263                 break;
 264             }
 265         }
 266         Ok(nread)
 267     }
 268
 269     fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
 270         let n = buf.len();
 271         Read::read_exact(&mut self.fill_buf()?, buf)?;
 272         self.pos += n as u64;
 273         Ok(())
 274     }
 275
 276     #[inline]
 277     unsafe fn initializer(&self) -> Initializer {
 278         Initializer::nop()
 279     }
 280 }
 281
 282 #[stable(feature = "rust1", since = "1.0.0")]
 283 impl<T> BufRead for Cursor<T>
 284 where
 285     T: AsRef<[u8]>,
 286 {
 287     fn fill_buf(&mut self) -> io::Result<&[u8]> {
 288         let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
 289         Ok(&self.inner.as_ref()[(amt as usize)..])
 290     }
 291     fn consume(&mut self, amt: usize) {
 292         self.pos += amt as u64;
 293     }
 294 }
 295
 296 // Non-resizing write implementation
 297 #[inline]
 298 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
 299     let pos = cmp::min(*pos_mut, slice.len() as u64);
 300     let amt = (&mut slice[(pos as usize)..]).write(buf)?;
 301     *pos_mut += amt as u64;
 302     Ok(amt)
 303 }
 304
 305 #[inline]
 306 fn slice_write_vectored(
 307     pos_mut: &mut u64,
 308     slice: &mut [u8],
 309     bufs: &[IoSlice<'_>],
 310 ) -> io::Result<usize> {
 311     let mut nwritten = 0;
 312     for buf in bufs {
 313         let n = slice_write(pos_mut, slice, buf)?;
 314         nwritten += n;
 315         if n < buf.len() {
 316             break;
 317         }
 318     }
 319     Ok(nwritten)
 320 }
 321
 322 // Resizing write implementation
 323 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
 324     let pos: usize = (*pos_mut).try_into().map_err(|_| {
 325         Error::new(
 326             ErrorKind::InvalidInput,
 327             "cursor position exceeds maximum possible vector length",
 328         )
 329     })?;
 330     // Make sure the internal buffer is as least as big as where we
 331     // currently are
 332     let len = vec.len();
 333     if len < pos {
 334         // use `resize` so that the zero filling is as efficient as possible
 335         vec.resize(pos, 0);
 336     }
 337     // Figure out what bytes will be used to overwrite what's currently
 338     // there (left), and what will be appended on the end (right)
 339     {
 340         let space = vec.len() - pos;
 341         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
 342         vec[pos..pos + left.len()].copy_from_slice(left);
 343         vec.extend_from_slice(right);
 344     }
 345
 346     // Bump us forward
 347     *pos_mut = (pos + buf.len()) as u64;
 348     Ok(buf.len())
 349 }
 350
 351 fn vec_write_vectored(
 352     pos_mut: &mut u64,
 353     vec: &mut Vec<u8>,
 354     bufs: &[IoSlice<'_>],
 355 ) -> io::Result<usize> {
 356     let mut nwritten = 0;
 357     for buf in bufs {
 358         nwritten += vec_write(pos_mut, vec, buf)?;
 359     }
 360     Ok(nwritten)
 361 }
 362
 363 #[stable(feature = "rust1", since = "1.0.0")]
 364 impl Write for Cursor<&mut [u8]> {
 365     #[inline]
 366     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 367         slice_write(&mut self.pos, self.inner, buf)
 368     }
 369
 370     #[inline]
 371     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 372         slice_write_vectored(&mut self.pos, self.inner, bufs)
 373     }
 374
 375     #[inline]
 376     fn flush(&mut self) -> io::Result<()> {
 377         Ok(())
 378     }
 379 }
 380
 381 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
 382 impl Write for Cursor<&mut Vec<u8>> {
 383     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 384         vec_write(&mut self.pos, self.inner, buf)
 385     }
 386
 387     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 388         vec_write_vectored(&mut self.pos, self.inner, bufs)
 389     }
 390
 391     #[inline]
 392     fn flush(&mut self) -> io::Result<()> {
 393         Ok(())
 394     }
 395 }
 396
 397 #[stable(feature = "rust1", since = "1.0.0")]
 398 impl Write for Cursor<Vec<u8>> {
 399     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 400         vec_write(&mut self.pos, &mut self.inner, buf)
 401     }
 402
 403     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 404         vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
 405     }
 406
 407     #[inline]
 408     fn flush(&mut self) -> io::Result<()> {
 409         Ok(())
 410     }
 411 }
 412
 413 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 414 impl Write for Cursor<Box<[u8]>> {
 415     #[inline]
 416     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 417         slice_write(&mut self.pos, &mut self.inner, buf)
 418     }
 419
 420     #[inline]
 421     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 422         slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
 423     }
 424
 425     #[inline]
 426     fn flush(&mut self) -> io::Result<()> {
 427         Ok(())
 428     }
 429 }
 430
 431 #[cfg(test)]
 432 mod tests {
 433     use crate::io::prelude::*;
 434     use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
 435
 436     #[test]
 437     fn test_vec_writer() {
 438         let mut writer = Vec::new();
 439         assert_eq!(writer.write(&[0]).unwrap(), 1);
 440         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 441         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 442         assert_eq!(
 443             writer
 444                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 445                 .unwrap(),
 446             3
 447         );
 448         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 449         assert_eq!(writer, b);
 450     }
 451
 452     #[test]
 453     fn test_mem_writer() {
 454         let mut writer = Cursor::new(Vec::new());
 455         assert_eq!(writer.write(&[0]).unwrap(), 1);
 456         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 457         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 458         assert_eq!(
 459             writer
 460                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 461                 .unwrap(),
 462             3
 463         );
 464         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 465         assert_eq!(&writer.get_ref()[..], b);
 466     }
 467
 468     #[test]
 469     fn test_mem_mut_writer() {
 470         let mut vec = Vec::new();
 471         let mut writer = Cursor::new(&mut vec);
 472         assert_eq!(writer.write(&[0]).unwrap(), 1);
 473         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 474         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 475         assert_eq!(
 476             writer
 477                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 478                 .unwrap(),
 479             3
 480         );
 481         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 482         assert_eq!(&writer.get_ref()[..], b);
 483     }
 484
 485     #[test]
 486     fn test_box_slice_writer() {
 487         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 488         assert_eq!(writer.position(), 0);
 489         assert_eq!(writer.write(&[0]).unwrap(), 1);
 490         assert_eq!(writer.position(), 1);
 491         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 492         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 493         assert_eq!(writer.position(), 8);
 494         assert_eq!(writer.write(&[]).unwrap(), 0);
 495         assert_eq!(writer.position(), 8);
 496
 497         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 498         assert_eq!(writer.write(&[10]).unwrap(), 0);
 499         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 500         assert_eq!(&**writer.get_ref(), b);
 501     }
 502
 503     #[test]
 504     fn test_box_slice_writer_vectored() {
 505         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 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
 511                 .write_vectored(&[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         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 522         assert_eq!(&**writer.get_ref(), b);
 523     }
 524
 525     #[test]
 526     fn test_buf_writer() {
 527         let mut buf = [0 as u8; 9];
 528         {
 529             let mut writer = Cursor::new(&mut buf[..]);
 530             assert_eq!(writer.position(), 0);
 531             assert_eq!(writer.write(&[0]).unwrap(), 1);
 532             assert_eq!(writer.position(), 1);
 533             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 534             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 535             assert_eq!(writer.position(), 8);
 536             assert_eq!(writer.write(&[]).unwrap(), 0);
 537             assert_eq!(writer.position(), 8);
 538
 539             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 540             assert_eq!(writer.write(&[10]).unwrap(), 0);
 541         }
 542         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 543         assert_eq!(buf, b);
 544     }
 545
 546     #[test]
 547     fn test_buf_writer_vectored() {
 548         let mut buf = [0 as u8; 9];
 549         {
 550             let mut writer = Cursor::new(&mut buf[..]);
 551             assert_eq!(writer.position(), 0);
 552             assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 553             assert_eq!(writer.position(), 1);
 554             assert_eq!(
 555                 writer
 556                     .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
 557                     .unwrap(),
 558                 7,
 559             );
 560             assert_eq!(writer.position(), 8);
 561             assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 562             assert_eq!(writer.position(), 8);
 563
 564             assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 565             assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 566         }
 567         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 568         assert_eq!(buf, b);
 569     }
 570
 571     #[test]
 572     fn test_buf_writer_seek() {
 573         let mut buf = [0 as u8; 8];
 574         {
 575             let mut writer = Cursor::new(&mut buf[..]);
 576             assert_eq!(writer.position(), 0);
 577             assert_eq!(writer.write(&[1]).unwrap(), 1);
 578             assert_eq!(writer.position(), 1);
 579
 580             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 581             assert_eq!(writer.position(), 2);
 582             assert_eq!(writer.write(&[2]).unwrap(), 1);
 583             assert_eq!(writer.position(), 3);
 584
 585             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 586             assert_eq!(writer.position(), 1);
 587             assert_eq!(writer.write(&[3]).unwrap(), 1);
 588             assert_eq!(writer.position(), 2);
 589
 590             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 591             assert_eq!(writer.position(), 7);
 592             assert_eq!(writer.write(&[4]).unwrap(), 1);
 593             assert_eq!(writer.position(), 8);
 594         }
 595         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 596         assert_eq!(buf, b);
 597     }
 598
 599     #[test]
 600     fn test_buf_writer_error() {
 601         let mut buf = [0 as u8; 2];
 602         let mut writer = Cursor::new(&mut buf[..]);
 603         assert_eq!(writer.write(&[0]).unwrap(), 1);
 604         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 605         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 606     }
 607
 608     #[test]
 609     fn test_mem_reader() {
 610         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 611         let mut buf = [];
 612         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 613         assert_eq!(reader.position(), 0);
 614         let mut buf = [0];
 615         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 616         assert_eq!(reader.position(), 1);
 617         let b: &[_] = &[0];
 618         assert_eq!(buf, b);
 619         let mut buf = [0; 4];
 620         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 621         assert_eq!(reader.position(), 5);
 622         let b: &[_] = &[1, 2, 3, 4];
 623         assert_eq!(buf, b);
 624         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 625         let b: &[_] = &[5, 6, 7];
 626         assert_eq!(&buf[..3], b);
 627         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 628     }
 629
 630     #[test]
 631     fn test_mem_reader_vectored() {
 632         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 633         let mut buf = [];
 634         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 635         assert_eq!(reader.position(), 0);
 636         let mut buf = [0];
 637         assert_eq!(
 638             reader
 639                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 640                 .unwrap(),
 641             1,
 642         );
 643         assert_eq!(reader.position(), 1);
 644         let b: &[_] = &[0];
 645         assert_eq!(buf, b);
 646         let mut buf1 = [0; 4];
 647         let mut buf2 = [0; 4];
 648         assert_eq!(
 649             reader
 650                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
 651                 .unwrap(),
 652             7,
 653         );
 654         let b1: &[_] = &[1, 2, 3, 4];
 655         let b2: &[_] = &[5, 6, 7];
 656         assert_eq!(buf1, b1);
 657         assert_eq!(&buf2[..3], b2);
 658         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 659     }
 660
 661     #[test]
 662     fn test_boxed_slice_reader() {
 663         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 664         let mut buf = [];
 665         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 666         assert_eq!(reader.position(), 0);
 667         let mut buf = [0];
 668         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 669         assert_eq!(reader.position(), 1);
 670         let b: &[_] = &[0];
 671         assert_eq!(buf, b);
 672         let mut buf = [0; 4];
 673         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 674         assert_eq!(reader.position(), 5);
 675         let b: &[_] = &[1, 2, 3, 4];
 676         assert_eq!(buf, b);
 677         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 678         let b: &[_] = &[5, 6, 7];
 679         assert_eq!(&buf[..3], b);
 680         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 681     }
 682
 683     #[test]
 684     fn test_boxed_slice_reader_vectored() {
 685         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 686         let mut buf = [];
 687         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 688         assert_eq!(reader.position(), 0);
 689         let mut buf = [0];
 690         assert_eq!(
 691             reader
 692                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 693                 .unwrap(),
 694             1,
 695         );
 696         assert_eq!(reader.position(), 1);
 697         let b: &[_] = &[0];
 698         assert_eq!(buf, b);
 699         let mut buf1 = [0; 4];
 700         let mut buf2 = [0; 4];
 701         assert_eq!(
 702             reader
 703                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 704                 .unwrap(),
 705             7,
 706         );
 707         let b1: &[_] = &[1, 2, 3, 4];
 708         let b2: &[_] = &[5, 6, 7];
 709         assert_eq!(buf1, b1);
 710         assert_eq!(&buf2[..3], b2);
 711         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 712     }
 713
 714     #[test]
 715     fn read_to_end() {
 716         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 717         let mut v = Vec::new();
 718         reader.read_to_end(&mut v).unwrap();
 719         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 720     }
 721
 722     #[test]
 723     fn test_slice_reader() {
 724         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 725         let reader = &mut &in_buf[..];
 726         let mut buf = [];
 727         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 728         let mut buf = [0];
 729         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 730         assert_eq!(reader.len(), 7);
 731         let b: &[_] = &[0];
 732         assert_eq!(&buf[..], b);
 733         let mut buf = [0; 4];
 734         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 735         assert_eq!(reader.len(), 3);
 736         let b: &[_] = &[1, 2, 3, 4];
 737         assert_eq!(&buf[..], b);
 738         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 739         let b: &[_] = &[5, 6, 7];
 740         assert_eq!(&buf[..3], b);
 741         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 742     }
 743
 744     #[test]
 745     fn test_slice_reader_vectored() {
 746         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 747         let reader = &mut &in_buf[..];
 748         let mut buf = [];
 749         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 750         let mut buf = [0];
 751         assert_eq!(
 752             reader
 753                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 754                 .unwrap(),
 755             1,
 756         );
 757         assert_eq!(reader.len(), 7);
 758         let b: &[_] = &[0];
 759         assert_eq!(buf, b);
 760         let mut buf1 = [0; 4];
 761         let mut buf2 = [0; 4];
 762         assert_eq!(
 763             reader
 764                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 765                 .unwrap(),
 766             7,
 767         );
 768         let b1: &[_] = &[1, 2, 3, 4];
 769         let b2: &[_] = &[5, 6, 7];
 770         assert_eq!(buf1, b1);
 771         assert_eq!(&buf2[..3], b2);
 772         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 773     }
 774
 775     #[test]
 776     fn test_read_exact() {
 777         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 778         let reader = &mut &in_buf[..];
 779         let mut buf = [];
 780         assert!(reader.read_exact(&mut buf).is_ok());
 781         let mut buf = [8];
 782         assert!(reader.read_exact(&mut buf).is_ok());
 783         assert_eq!(buf[0], 0);
 784         assert_eq!(reader.len(), 7);
 785         let mut buf = [0, 0, 0, 0, 0, 0, 0];
 786         assert!(reader.read_exact(&mut buf).is_ok());
 787         assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
 788         assert_eq!(reader.len(), 0);
 789         let mut buf = [0];
 790         assert!(reader.read_exact(&mut buf).is_err());
 791     }
 792
 793     #[test]
 794     fn test_buf_reader() {
 795         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 796         let mut reader = Cursor::new(&in_buf[..]);
 797         let mut buf = [];
 798         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 799         assert_eq!(reader.position(), 0);
 800         let mut buf = [0];
 801         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 802         assert_eq!(reader.position(), 1);
 803         let b: &[_] = &[0];
 804         assert_eq!(buf, b);
 805         let mut buf = [0; 4];
 806         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 807         assert_eq!(reader.position(), 5);
 808         let b: &[_] = &[1, 2, 3, 4];
 809         assert_eq!(buf, b);
 810         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 811         let b: &[_] = &[5, 6, 7];
 812         assert_eq!(&buf[..3], b);
 813         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 814     }
 815
 816     #[test]
 817     fn seek_past_end() {
 818         let buf = [0xff];
 819         let mut r = Cursor::new(&buf[..]);
 820         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 821         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 822
 823         let mut r = Cursor::new(vec![10]);
 824         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 825         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 826
 827         let mut buf = [0];
 828         let mut r = Cursor::new(&mut buf[..]);
 829         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 830         assert_eq!(r.write(&[3]).unwrap(), 0);
 831
 832         let mut r = Cursor::new(vec![10].into_boxed_slice());
 833         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 834         assert_eq!(r.write(&[3]).unwrap(), 0);
 835     }
 836
 837     #[test]
 838     fn seek_past_i64() {
 839         let buf = [0xff];
 840         let mut r = Cursor::new(&buf[..]);
 841         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 842         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 843         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 844         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 845         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 846         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 847
 848         let mut r = Cursor::new(vec![10]);
 849         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 850         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 851         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 852         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 853         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 854         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 855
 856         let mut buf = [0];
 857         let mut r = Cursor::new(&mut buf[..]);
 858         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 859         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 860         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 861         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 862         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 863         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 864
 865         let mut r = Cursor::new(vec![10].into_boxed_slice());
 866         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 867         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 868         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 869         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 870         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 871         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 872     }
 873
 874     #[test]
 875     fn seek_before_0() {
 876         let buf = [0xff];
 877         let mut r = Cursor::new(&buf[..]);
 878         assert!(r.seek(SeekFrom::End(-2)).is_err());
 879
 880         let mut r = Cursor::new(vec![10]);
 881         assert!(r.seek(SeekFrom::End(-2)).is_err());
 882
 883         let mut buf = [0];
 884         let mut r = Cursor::new(&mut buf[..]);
 885         assert!(r.seek(SeekFrom::End(-2)).is_err());
 886
 887         let mut r = Cursor::new(vec![10].into_boxed_slice());
 888         assert!(r.seek(SeekFrom::End(-2)).is_err());
 889     }
 890
 891     #[test]
 892     fn test_seekable_mem_writer() {
 893         let mut writer = Cursor::new(Vec::<u8>::new());
 894         assert_eq!(writer.position(), 0);
 895         assert_eq!(writer.write(&[0]).unwrap(), 1);
 896         assert_eq!(writer.position(), 1);
 897         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 898         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 899         assert_eq!(writer.position(), 8);
 900         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 901         assert_eq!(&writer.get_ref()[..], b);
 902
 903         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 904         assert_eq!(writer.position(), 0);
 905         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 906         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 907         assert_eq!(&writer.get_ref()[..], b);
 908
 909         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 910         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 911         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 912         assert_eq!(&writer.get_ref()[..], b);
 913
 914         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 915         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 916         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 917         assert_eq!(&writer.get_ref()[..], b);
 918
 919         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 920         assert_eq!(writer.write(&[1]).unwrap(), 1);
 921         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 922         assert_eq!(&writer.get_ref()[..], b);
 923     }
 924
 925     #[test]
 926     fn vec_seek_past_end() {
 927         let mut r = Cursor::new(Vec::new());
 928         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 929         assert_eq!(r.write(&[3]).unwrap(), 1);
 930     }
 931
 932     #[test]
 933     fn vec_seek_before_0() {
 934         let mut r = Cursor::new(Vec::new());
 935         assert!(r.seek(SeekFrom::End(-2)).is_err());
 936     }
 937
 938     #[test]
 939     #[cfg(target_pointer_width = "32")]
 940     fn vec_seek_and_write_past_usize_max() {
 941         let mut c = Cursor::new(Vec::new());
 942         c.set_position(<usize>::max_value() as u64 + 1);
 943         assert!(c.write_all(&[1, 2, 3]).is_err());
 944     }
 945
 946     #[test]
 947     fn test_partial_eq() {
 948         assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
 949     }
 950
 951     #[test]
 952     fn test_eq() {
 953         struct AssertEq<T: Eq>(pub T);
 954
 955         let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
 956     }
 957 }