library/std/src/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 /// [bytes]: crate::slice
  27 /// [`File`]: crate::fs::File
  28 ///
  29 /// ```no_run
  30 /// use std::io::prelude::*;
  31 /// use std::io::{self, SeekFrom};
  32 /// use std::fs::File;
  33 ///
  34 /// // a library function we've written
  35 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
  36 ///     writer.seek(SeekFrom::End(-10))?;
  37 ///
  38 ///     for i in 0..10 {
  39 ///         writer.write(&[i])?;
  40 ///     }
  41 ///
  42 ///     // all went well
  43 ///     Ok(())
  44 /// }
  45 ///
  46 /// # fn foo() -> io::Result<()> {
  47 /// // Here's some code that uses this library function.
  48 /// //
  49 /// // We might want to use a BufReader here for efficiency, but let's
  50 /// // keep this example focused.
  51 /// let mut file = File::create("foo.txt")?;
  52 ///
  53 /// write_ten_bytes_at_end(&mut file)?;
  54 /// # Ok(())
  55 /// # }
  56 ///
  57 /// // now let's write a test
  58 /// #[test]
  59 /// fn test_writes_bytes() {
  60 ///     // setting up a real File is much slower than an in-memory buffer,
  61 ///     // let's use a cursor instead
  62 ///     use std::io::Cursor;
  63 ///     let mut buff = Cursor::new(vec![0; 15]);
  64 ///
  65 ///     write_ten_bytes_at_end(&mut buff).unwrap();
  66 ///
  67 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  68 /// }
  69 /// ```
  70 #[stable(feature = "rust1", since = "1.0.0")]
  71 #[derive(Clone, Debug, Default, Eq, PartialEq)]
  72 pub struct Cursor<T> {
  73     inner: T,
  74     pos: u64,
  75 }
  76
  77 impl<T> Cursor<T> {
  78     /// Creates a new cursor wrapping the provided underlying in-memory buffer.
  79     ///
  80     /// Cursor initial position is `0` even if underlying buffer (e.g., [`Vec`])
  81     /// is not empty. So writing to cursor starts with overwriting [`Vec`]
  82     /// content, not with appending to it.
  83     ///
  84     /// # Examples
  85     ///
  86     /// ```
  87     /// use std::io::Cursor;
  88     ///
  89     /// let buff = Cursor::new(Vec::new());
  90     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
  91     /// # force_inference(&buff);
  92     /// ```
  93     #[stable(feature = "rust1", since = "1.0.0")]
  94     pub fn new(inner: T) -> Cursor<T> {
  95         Cursor { pos: 0, inner }
  96     }
  97
  98     /// Consumes this cursor, returning the underlying value.
  99     ///
 100     /// # Examples
 101     ///
 102     /// ```
 103     /// use std::io::Cursor;
 104     ///
 105     /// let buff = Cursor::new(Vec::new());
 106     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 107     /// # force_inference(&buff);
 108     ///
 109     /// let vec = buff.into_inner();
 110     /// ```
 111     #[stable(feature = "rust1", since = "1.0.0")]
 112     pub fn into_inner(self) -> T {
 113         self.inner
 114     }
 115
 116     /// Gets a reference to the underlying value in this cursor.
 117     ///
 118     /// # Examples
 119     ///
 120     /// ```
 121     /// use std::io::Cursor;
 122     ///
 123     /// let buff = Cursor::new(Vec::new());
 124     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 125     /// # force_inference(&buff);
 126     ///
 127     /// let reference = buff.get_ref();
 128     /// ```
 129     #[stable(feature = "rust1", since = "1.0.0")]
 130     pub fn get_ref(&self) -> &T {
 131         &self.inner
 132     }
 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 {
 152         &mut self.inner
 153     }
 154
 155     /// Returns the current position of this cursor.
 156     ///
 157     /// # Examples
 158     ///
 159     /// ```
 160     /// use std::io::Cursor;
 161     /// use std::io::prelude::*;
 162     /// use std::io::SeekFrom;
 163     ///
 164     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 165     ///
 166     /// assert_eq!(buff.position(), 0);
 167     ///
 168     /// buff.seek(SeekFrom::Current(2)).unwrap();
 169     /// assert_eq!(buff.position(), 2);
 170     ///
 171     /// buff.seek(SeekFrom::Current(-1)).unwrap();
 172     /// assert_eq!(buff.position(), 1);
 173     /// ```
 174     #[stable(feature = "rust1", since = "1.0.0")]
 175     pub fn position(&self) -> u64 {
 176         self.pos
 177     }
 178
 179     /// Sets the position of this cursor.
 180     ///
 181     /// # Examples
 182     ///
 183     /// ```
 184     /// use std::io::Cursor;
 185     ///
 186     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 187     ///
 188     /// assert_eq!(buff.position(), 0);
 189     ///
 190     /// buff.set_position(2);
 191     /// assert_eq!(buff.position(), 2);
 192     ///
 193     /// buff.set_position(4);
 194     /// assert_eq!(buff.position(), 4);
 195     /// ```
 196     #[stable(feature = "rust1", since = "1.0.0")]
 197     pub fn set_position(&mut self, pos: u64) {
 198         self.pos = pos;
 199     }
 200 }
 201
 202 #[stable(feature = "rust1", since = "1.0.0")]
 203 impl<T> io::Seek for Cursor<T>
 204 where
 205     T: AsRef<[u8]>,
 206 {
 207     fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
 208         let (base_pos, offset) = match style {
 209             SeekFrom::Start(n) => {
 210                 self.pos = n;
 211                 return Ok(n);
 212             }
 213             SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
 214             SeekFrom::Current(n) => (self.pos, n),
 215         };
 216         let new_pos = if offset >= 0 {
 217             base_pos.checked_add(offset as u64)
 218         } else {
 219             base_pos.checked_sub((offset.wrapping_neg()) as u64)
 220         };
 221         match new_pos {
 222             Some(n) => {
 223                 self.pos = n;
 224                 Ok(self.pos)
 225             }
 226             None => Err(Error::new(
 227                 ErrorKind::InvalidInput,
 228                 "invalid seek to a negative or overflowing position",
 229             )),
 230         }
 231     }
 232
 233     fn stream_len(&mut self) -> io::Result<u64> {
 234         Ok(self.inner.as_ref().len() as u64)
 235     }
 236
 237     fn stream_position(&mut self) -> io::Result<u64> {
 238         Ok(self.pos)
 239     }
 240 }
 241
 242 #[stable(feature = "rust1", since = "1.0.0")]
 243 impl<T> Read for Cursor<T>
 244 where
 245     T: AsRef<[u8]>,
 246 {
 247     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 248         let n = Read::read(&mut self.fill_buf()?, buf)?;
 249         self.pos += n as u64;
 250         Ok(n)
 251     }
 252
 253     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
 254         let mut nread = 0;
 255         for buf in bufs {
 256             let n = self.read(buf)?;
 257             nread += n;
 258             if n < buf.len() {
 259                 break;
 260             }
 261         }
 262         Ok(nread)
 263     }
 264
 265     fn is_read_vectored(&self) -> bool {
 266         true
 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 is_write_vectored(&self) -> bool {
 377         true
 378     }
 379
 380     #[inline]
 381     fn flush(&mut self) -> io::Result<()> {
 382         Ok(())
 383     }
 384 }
 385
 386 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
 387 impl Write for Cursor<&mut Vec<u8>> {
 388     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 389         vec_write(&mut self.pos, self.inner, buf)
 390     }
 391
 392     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 393         vec_write_vectored(&mut self.pos, self.inner, bufs)
 394     }
 395
 396     #[inline]
 397     fn is_write_vectored(&self) -> bool {
 398         true
 399     }
 400
 401     #[inline]
 402     fn flush(&mut self) -> io::Result<()> {
 403         Ok(())
 404     }
 405 }
 406
 407 #[stable(feature = "rust1", since = "1.0.0")]
 408 impl Write for Cursor<Vec<u8>> {
 409     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 410         vec_write(&mut self.pos, &mut self.inner, buf)
 411     }
 412
 413     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 414         vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
 415     }
 416
 417     #[inline]
 418     fn is_write_vectored(&self) -> bool {
 419         true
 420     }
 421
 422     #[inline]
 423     fn flush(&mut self) -> io::Result<()> {
 424         Ok(())
 425     }
 426 }
 427
 428 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 429 impl Write for Cursor<Box<[u8]>> {
 430     #[inline]
 431     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 432         slice_write(&mut self.pos, &mut self.inner, buf)
 433     }
 434
 435     #[inline]
 436     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
 437         slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
 438     }
 439
 440     #[inline]
 441     fn is_write_vectored(&self) -> bool {
 442         true
 443     }
 444
 445     #[inline]
 446     fn flush(&mut self) -> io::Result<()> {
 447         Ok(())
 448     }
 449 }
 450
 451 #[cfg(test)]
 452 mod tests {
 453     use crate::io::prelude::*;
 454     use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
 455
 456     #[test]
 457     fn test_vec_writer() {
 458         let mut writer = Vec::new();
 459         assert_eq!(writer.write(&[0]).unwrap(), 1);
 460         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 461         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 462         assert_eq!(
 463             writer
 464                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 465                 .unwrap(),
 466             3
 467         );
 468         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 469         assert_eq!(writer, b);
 470     }
 471
 472     #[test]
 473     fn test_mem_writer() {
 474         let mut writer = Cursor::new(Vec::new());
 475         assert_eq!(writer.write(&[0]).unwrap(), 1);
 476         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 477         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 478         assert_eq!(
 479             writer
 480                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 481                 .unwrap(),
 482             3
 483         );
 484         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 485         assert_eq!(&writer.get_ref()[..], b);
 486     }
 487
 488     #[test]
 489     fn test_mem_mut_writer() {
 490         let mut vec = Vec::new();
 491         let mut writer = Cursor::new(&mut vec);
 492         assert_eq!(writer.write(&[0]).unwrap(), 1);
 493         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 494         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 495         assert_eq!(
 496             writer
 497                 .write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
 498                 .unwrap(),
 499             3
 500         );
 501         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 502         assert_eq!(&writer.get_ref()[..], b);
 503     }
 504
 505     #[test]
 506     fn test_box_slice_writer() {
 507         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 508         assert_eq!(writer.position(), 0);
 509         assert_eq!(writer.write(&[0]).unwrap(), 1);
 510         assert_eq!(writer.position(), 1);
 511         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 512         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 513         assert_eq!(writer.position(), 8);
 514         assert_eq!(writer.write(&[]).unwrap(), 0);
 515         assert_eq!(writer.position(), 8);
 516
 517         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 518         assert_eq!(writer.write(&[10]).unwrap(), 0);
 519         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 520         assert_eq!(&**writer.get_ref(), b);
 521     }
 522
 523     #[test]
 524     fn test_box_slice_writer_vectored() {
 525         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 526         assert_eq!(writer.position(), 0);
 527         assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 528         assert_eq!(writer.position(), 1);
 529         assert_eq!(
 530             writer
 531                 .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
 532                 .unwrap(),
 533             7,
 534         );
 535         assert_eq!(writer.position(), 8);
 536         assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 537         assert_eq!(writer.position(), 8);
 538
 539         assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 540         assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 541         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 542         assert_eq!(&**writer.get_ref(), b);
 543     }
 544
 545     #[test]
 546     fn test_buf_writer() {
 547         let mut buf = [0 as u8; 9];
 548         {
 549             let mut writer = Cursor::new(&mut buf[..]);
 550             assert_eq!(writer.position(), 0);
 551             assert_eq!(writer.write(&[0]).unwrap(), 1);
 552             assert_eq!(writer.position(), 1);
 553             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 554             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 555             assert_eq!(writer.position(), 8);
 556             assert_eq!(writer.write(&[]).unwrap(), 0);
 557             assert_eq!(writer.position(), 8);
 558
 559             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 560             assert_eq!(writer.write(&[10]).unwrap(), 0);
 561         }
 562         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 563         assert_eq!(buf, b);
 564     }
 565
 566     #[test]
 567     fn test_buf_writer_vectored() {
 568         let mut buf = [0 as u8; 9];
 569         {
 570             let mut writer = Cursor::new(&mut buf[..]);
 571             assert_eq!(writer.position(), 0);
 572             assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
 573             assert_eq!(writer.position(), 1);
 574             assert_eq!(
 575                 writer
 576                     .write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
 577                     .unwrap(),
 578                 7,
 579             );
 580             assert_eq!(writer.position(), 8);
 581             assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
 582             assert_eq!(writer.position(), 8);
 583
 584             assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
 585             assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
 586         }
 587         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 588         assert_eq!(buf, b);
 589     }
 590
 591     #[test]
 592     fn test_buf_writer_seek() {
 593         let mut buf = [0 as u8; 8];
 594         {
 595             let mut writer = Cursor::new(&mut buf[..]);
 596             assert_eq!(writer.position(), 0);
 597             assert_eq!(writer.write(&[1]).unwrap(), 1);
 598             assert_eq!(writer.position(), 1);
 599
 600             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 601             assert_eq!(writer.position(), 2);
 602             assert_eq!(writer.write(&[2]).unwrap(), 1);
 603             assert_eq!(writer.position(), 3);
 604
 605             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 606             assert_eq!(writer.position(), 1);
 607             assert_eq!(writer.write(&[3]).unwrap(), 1);
 608             assert_eq!(writer.position(), 2);
 609
 610             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 611             assert_eq!(writer.position(), 7);
 612             assert_eq!(writer.write(&[4]).unwrap(), 1);
 613             assert_eq!(writer.position(), 8);
 614         }
 615         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 616         assert_eq!(buf, b);
 617     }
 618
 619     #[test]
 620     fn test_buf_writer_error() {
 621         let mut buf = [0 as u8; 2];
 622         let mut writer = Cursor::new(&mut buf[..]);
 623         assert_eq!(writer.write(&[0]).unwrap(), 1);
 624         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 625         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 626     }
 627
 628     #[test]
 629     fn test_mem_reader() {
 630         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 631         let mut buf = [];
 632         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 633         assert_eq!(reader.position(), 0);
 634         let mut buf = [0];
 635         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 636         assert_eq!(reader.position(), 1);
 637         let b: &[_] = &[0];
 638         assert_eq!(buf, b);
 639         let mut buf = [0; 4];
 640         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 641         assert_eq!(reader.position(), 5);
 642         let b: &[_] = &[1, 2, 3, 4];
 643         assert_eq!(buf, b);
 644         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 645         let b: &[_] = &[5, 6, 7];
 646         assert_eq!(&buf[..3], b);
 647         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 648     }
 649
 650     #[test]
 651     fn test_mem_reader_vectored() {
 652         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 653         let mut buf = [];
 654         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 655         assert_eq!(reader.position(), 0);
 656         let mut buf = [0];
 657         assert_eq!(
 658             reader
 659                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 660                 .unwrap(),
 661             1,
 662         );
 663         assert_eq!(reader.position(), 1);
 664         let b: &[_] = &[0];
 665         assert_eq!(buf, b);
 666         let mut buf1 = [0; 4];
 667         let mut buf2 = [0; 4];
 668         assert_eq!(
 669             reader
 670                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
 671                 .unwrap(),
 672             7,
 673         );
 674         let b1: &[_] = &[1, 2, 3, 4];
 675         let b2: &[_] = &[5, 6, 7];
 676         assert_eq!(buf1, b1);
 677         assert_eq!(&buf2[..3], b2);
 678         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 679     }
 680
 681     #[test]
 682     fn test_boxed_slice_reader() {
 683         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 684         let mut buf = [];
 685         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 686         assert_eq!(reader.position(), 0);
 687         let mut buf = [0];
 688         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 689         assert_eq!(reader.position(), 1);
 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.position(), 5);
 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_boxed_slice_reader_vectored() {
 705         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 706         let mut buf = [];
 707         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 708         assert_eq!(reader.position(), 0);
 709         let mut buf = [0];
 710         assert_eq!(
 711             reader
 712                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 713                 .unwrap(),
 714             1,
 715         );
 716         assert_eq!(reader.position(), 1);
 717         let b: &[_] = &[0];
 718         assert_eq!(buf, b);
 719         let mut buf1 = [0; 4];
 720         let mut buf2 = [0; 4];
 721         assert_eq!(
 722             reader
 723                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 724                 .unwrap(),
 725             7,
 726         );
 727         let b1: &[_] = &[1, 2, 3, 4];
 728         let b2: &[_] = &[5, 6, 7];
 729         assert_eq!(buf1, b1);
 730         assert_eq!(&buf2[..3], b2);
 731         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 732     }
 733
 734     #[test]
 735     fn read_to_end() {
 736         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 737         let mut v = Vec::new();
 738         reader.read_to_end(&mut v).unwrap();
 739         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 740     }
 741
 742     #[test]
 743     fn test_slice_reader() {
 744         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 745         let reader = &mut &in_buf[..];
 746         let mut buf = [];
 747         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 748         let mut buf = [0];
 749         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 750         assert_eq!(reader.len(), 7);
 751         let b: &[_] = &[0];
 752         assert_eq!(&buf[..], b);
 753         let mut buf = [0; 4];
 754         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 755         assert_eq!(reader.len(), 3);
 756         let b: &[_] = &[1, 2, 3, 4];
 757         assert_eq!(&buf[..], b);
 758         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 759         let b: &[_] = &[5, 6, 7];
 760         assert_eq!(&buf[..3], b);
 761         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 762     }
 763
 764     #[test]
 765     fn test_slice_reader_vectored() {
 766         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 767         let reader = &mut &in_buf[..];
 768         let mut buf = [];
 769         assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
 770         let mut buf = [0];
 771         assert_eq!(
 772             reader
 773                 .read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
 774                 .unwrap(),
 775             1,
 776         );
 777         assert_eq!(reader.len(), 7);
 778         let b: &[_] = &[0];
 779         assert_eq!(buf, b);
 780         let mut buf1 = [0; 4];
 781         let mut buf2 = [0; 4];
 782         assert_eq!(
 783             reader
 784                 .read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
 785                 .unwrap(),
 786             7,
 787         );
 788         let b1: &[_] = &[1, 2, 3, 4];
 789         let b2: &[_] = &[5, 6, 7];
 790         assert_eq!(buf1, b1);
 791         assert_eq!(&buf2[..3], b2);
 792         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 793     }
 794
 795     #[test]
 796     fn test_read_exact() {
 797         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 798         let reader = &mut &in_buf[..];
 799         let mut buf = [];
 800         assert!(reader.read_exact(&mut buf).is_ok());
 801         let mut buf = [8];
 802         assert!(reader.read_exact(&mut buf).is_ok());
 803         assert_eq!(buf[0], 0);
 804         assert_eq!(reader.len(), 7);
 805         let mut buf = [0, 0, 0, 0, 0, 0, 0];
 806         assert!(reader.read_exact(&mut buf).is_ok());
 807         assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
 808         assert_eq!(reader.len(), 0);
 809         let mut buf = [0];
 810         assert!(reader.read_exact(&mut buf).is_err());
 811     }
 812
 813     #[test]
 814     fn test_buf_reader() {
 815         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 816         let mut reader = Cursor::new(&in_buf[..]);
 817         let mut buf = [];
 818         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 819         assert_eq!(reader.position(), 0);
 820         let mut buf = [0];
 821         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 822         assert_eq!(reader.position(), 1);
 823         let b: &[_] = &[0];
 824         assert_eq!(buf, b);
 825         let mut buf = [0; 4];
 826         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 827         assert_eq!(reader.position(), 5);
 828         let b: &[_] = &[1, 2, 3, 4];
 829         assert_eq!(buf, b);
 830         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 831         let b: &[_] = &[5, 6, 7];
 832         assert_eq!(&buf[..3], b);
 833         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 834     }
 835
 836     #[test]
 837     fn seek_past_end() {
 838         let buf = [0xff];
 839         let mut r = Cursor::new(&buf[..]);
 840         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 841         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 842
 843         let mut r = Cursor::new(vec![10]);
 844         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 845         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 846
 847         let mut buf = [0];
 848         let mut r = Cursor::new(&mut buf[..]);
 849         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 850         assert_eq!(r.write(&[3]).unwrap(), 0);
 851
 852         let mut r = Cursor::new(vec![10].into_boxed_slice());
 853         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 854         assert_eq!(r.write(&[3]).unwrap(), 0);
 855     }
 856
 857     #[test]
 858     fn seek_past_i64() {
 859         let buf = [0xff];
 860         let mut r = Cursor::new(&buf[..]);
 861         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 862         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 863         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 864         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 865         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 866         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 867
 868         let mut r = Cursor::new(vec![10]);
 869         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 870         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 871         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 872         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 873         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 874         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 875
 876         let mut buf = [0];
 877         let mut r = Cursor::new(&mut buf[..]);
 878         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 879         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 880         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 881         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 882         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 883         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 884
 885         let mut r = Cursor::new(vec![10].into_boxed_slice());
 886         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 887         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 888         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 889         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 890         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 891         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 892     }
 893
 894     #[test]
 895     fn seek_before_0() {
 896         let buf = [0xff];
 897         let mut r = Cursor::new(&buf[..]);
 898         assert!(r.seek(SeekFrom::End(-2)).is_err());
 899
 900         let mut r = Cursor::new(vec![10]);
 901         assert!(r.seek(SeekFrom::End(-2)).is_err());
 902
 903         let mut buf = [0];
 904         let mut r = Cursor::new(&mut buf[..]);
 905         assert!(r.seek(SeekFrom::End(-2)).is_err());
 906
 907         let mut r = Cursor::new(vec![10].into_boxed_slice());
 908         assert!(r.seek(SeekFrom::End(-2)).is_err());
 909     }
 910
 911     #[test]
 912     fn test_seekable_mem_writer() {
 913         let mut writer = Cursor::new(Vec::<u8>::new());
 914         assert_eq!(writer.position(), 0);
 915         assert_eq!(writer.write(&[0]).unwrap(), 1);
 916         assert_eq!(writer.position(), 1);
 917         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 918         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 919         assert_eq!(writer.position(), 8);
 920         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 921         assert_eq!(&writer.get_ref()[..], b);
 922
 923         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 924         assert_eq!(writer.position(), 0);
 925         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 926         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 927         assert_eq!(&writer.get_ref()[..], b);
 928
 929         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 930         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 931         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 932         assert_eq!(&writer.get_ref()[..], b);
 933
 934         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 935         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 936         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 937         assert_eq!(&writer.get_ref()[..], b);
 938
 939         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 940         assert_eq!(writer.write(&[1]).unwrap(), 1);
 941         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 942         assert_eq!(&writer.get_ref()[..], b);
 943     }
 944
 945     #[test]
 946     fn vec_seek_past_end() {
 947         let mut r = Cursor::new(Vec::new());
 948         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 949         assert_eq!(r.write(&[3]).unwrap(), 1);
 950     }
 951
 952     #[test]
 953     fn vec_seek_before_0() {
 954         let mut r = Cursor::new(Vec::new());
 955         assert!(r.seek(SeekFrom::End(-2)).is_err());
 956     }
 957
 958     #[test]
 959     #[cfg(target_pointer_width = "32")]
 960     fn vec_seek_and_write_past_usize_max() {
 961         let mut c = Cursor::new(Vec::new());
 962         c.set_position(usize::MAX as u64 + 1);
 963         assert!(c.write_all(&[1, 2, 3]).is_err());
 964     }
 965
 966     #[test]
 967     fn test_partial_eq() {
 968         assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
 969     }
 970
 971     #[test]
 972     fn test_eq() {
 973         struct AssertEq<T: Eq>(pub T);
 974
 975         let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
 976     }
 977 }