src/libstd/io/cursor.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use io::prelude::*;
  12
  13 use core::convert::TryInto;
  14 use cmp;
  15 use io::{self, Initializer, SeekFrom, Error, ErrorKind};
  16
  17 /// A `Cursor` wraps an in-memory buffer and provides it with a
  18 /// [`Seek`] implementation.
  19 ///
  20 /// `Cursor`s are used with in-memory buffers, anything implementing
  21 /// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
  22 /// allowing these buffers to be used anywhere you might use a reader or writer
  23 /// that does actual I/O.
  24 ///
  25 /// The standard library implements some I/O traits on various types which
  26 /// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
  27 /// `Cursor<`[`&[u8]`][bytes]`>`.
  28 ///
  29 /// # Examples
  30 ///
  31 /// We may want to write bytes to a [`File`] in our production
  32 /// code, but use an in-memory buffer in our tests. We can do this with
  33 /// `Cursor`:
  34 ///
  35 /// [`Seek`]: trait.Seek.html
  36 /// [`Read`]: ../../std/io/trait.Read.html
  37 /// [`Write`]: ../../std/io/trait.Write.html
  38 /// [`Vec`]: ../../std/vec/struct.Vec.html
  39 /// [bytes]: ../../std/primitive.slice.html
  40 /// [`File`]: ../fs/struct.File.html
  41 ///
  42 /// ```no_run
  43 /// use std::io::prelude::*;
  44 /// use std::io::{self, SeekFrom};
  45 /// use std::fs::File;
  46 ///
  47 /// // a library function we've written
  48 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
  49 ///     writer.seek(SeekFrom::End(-10))?;
  50 ///
  51 ///     for i in 0..10 {
  52 ///         writer.write(&[i])?;
  53 ///     }
  54 ///
  55 ///     // all went well
  56 ///     Ok(())
  57 /// }
  58 ///
  59 /// # fn foo() -> io::Result<()> {
  60 /// // Here's some code that uses this library function.
  61 /// //
  62 /// // We might want to use a BufReader here for efficiency, but let's
  63 /// // keep this example focused.
  64 /// let mut file = File::create("foo.txt")?;
  65 ///
  66 /// write_ten_bytes_at_end(&mut file)?;
  67 /// # Ok(())
  68 /// # }
  69 ///
  70 /// // now let's write a test
  71 /// #[test]
  72 /// fn test_writes_bytes() {
  73 ///     // setting up a real File is much slower than an in-memory buffer,
  74 ///     // let's use a cursor instead
  75 ///     use std::io::Cursor;
  76 ///     let mut buff = Cursor::new(vec![0; 15]);
  77 ///
  78 ///     write_ten_bytes_at_end(&mut buff).unwrap();
  79 ///
  80 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  81 /// }
  82 /// ```
  83 #[stable(feature = "rust1", since = "1.0.0")]
  84 #[derive(Clone, Debug)]
  85 pub struct Cursor<T> {
  86     inner: T,
  87     pos: u64,
  88 }
  89
  90 impl<T> Cursor<T> {
  91     /// Creates a new cursor wrapping the provided underlying in-memory buffer.
  92     ///
  93     /// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
  94     /// is not empty. So writing to cursor starts with overwriting `Vec`
  95     /// content, not with appending to it.
  96     ///
  97     /// # Examples
  98     ///
  99     /// ```
 100     /// use std::io::Cursor;
 101     ///
 102     /// let buff = Cursor::new(Vec::new());
 103     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 104     /// # force_inference(&buff);
 105     /// ```
 106     #[stable(feature = "rust1", since = "1.0.0")]
 107     pub fn new(inner: T) -> Cursor<T> {
 108         Cursor { pos: 0, inner: inner }
 109     }
 110
 111     /// Consumes this cursor, returning the underlying value.
 112     ///
 113     /// # Examples
 114     ///
 115     /// ```
 116     /// use std::io::Cursor;
 117     ///
 118     /// let buff = Cursor::new(Vec::new());
 119     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 120     /// # force_inference(&buff);
 121     ///
 122     /// let vec = buff.into_inner();
 123     /// ```
 124     #[stable(feature = "rust1", since = "1.0.0")]
 125     pub fn into_inner(self) -> T { self.inner }
 126
 127     /// Gets a reference to the underlying value in this cursor.
 128     ///
 129     /// # Examples
 130     ///
 131     /// ```
 132     /// use std::io::Cursor;
 133     ///
 134     /// let buff = Cursor::new(Vec::new());
 135     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 136     /// # force_inference(&buff);
 137     ///
 138     /// let reference = buff.get_ref();
 139     /// ```
 140     #[stable(feature = "rust1", since = "1.0.0")]
 141     pub fn get_ref(&self) -> &T { &self.inner }
 142
 143     /// Gets a mutable reference to the underlying value in this cursor.
 144     ///
 145     /// Care should be taken to avoid modifying the internal I/O state of the
 146     /// underlying value as it may corrupt this cursor's position.
 147     ///
 148     /// # Examples
 149     ///
 150     /// ```
 151     /// use std::io::Cursor;
 152     ///
 153     /// let mut buff = Cursor::new(Vec::new());
 154     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 155     /// # force_inference(&buff);
 156     ///
 157     /// let reference = buff.get_mut();
 158     /// ```
 159     #[stable(feature = "rust1", since = "1.0.0")]
 160     pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
 161
 162     /// Returns the current position of this cursor.
 163     ///
 164     /// # Examples
 165     ///
 166     /// ```
 167     /// use std::io::Cursor;
 168     /// use std::io::prelude::*;
 169     /// use std::io::SeekFrom;
 170     ///
 171     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 172     ///
 173     /// assert_eq!(buff.position(), 0);
 174     ///
 175     /// buff.seek(SeekFrom::Current(2)).unwrap();
 176     /// assert_eq!(buff.position(), 2);
 177     ///
 178     /// buff.seek(SeekFrom::Current(-1)).unwrap();
 179     /// assert_eq!(buff.position(), 1);
 180     /// ```
 181     #[stable(feature = "rust1", since = "1.0.0")]
 182     pub fn position(&self) -> u64 { self.pos }
 183
 184     /// Sets the position of this cursor.
 185     ///
 186     /// # Examples
 187     ///
 188     /// ```
 189     /// use std::io::Cursor;
 190     ///
 191     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 192     ///
 193     /// assert_eq!(buff.position(), 0);
 194     ///
 195     /// buff.set_position(2);
 196     /// assert_eq!(buff.position(), 2);
 197     ///
 198     /// buff.set_position(4);
 199     /// assert_eq!(buff.position(), 4);
 200     /// ```
 201     #[stable(feature = "rust1", since = "1.0.0")]
 202     pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
 203 }
 204
 205 #[stable(feature = "rust1", since = "1.0.0")]
 206 impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
 207     fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
 208         let (base_pos, offset) = match style {
 209             SeekFrom::Start(n) => { self.pos = n; return Ok(n); }
 210             SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
 211             SeekFrom::Current(n) => (self.pos, n),
 212         };
 213         let new_pos = if offset >= 0 {
 214             base_pos.checked_add(offset as u64)
 215         } else {
 216             base_pos.checked_sub((offset.wrapping_neg()) as u64)
 217         };
 218         match new_pos {
 219             Some(n) => {self.pos = n; Ok(self.pos)}
 220             None => Err(Error::new(ErrorKind::InvalidInput,
 221                            "invalid seek to a negative or overflowing position"))
 222         }
 223     }
 224 }
 225
 226 #[stable(feature = "rust1", since = "1.0.0")]
 227 impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
 228     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 229         let n = Read::read(&mut self.fill_buf()?, buf)?;
 230         self.pos += n as u64;
 231         Ok(n)
 232     }
 233
 234     fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
 235         let n = buf.len();
 236         Read::read_exact(&mut self.fill_buf()?, buf)?;
 237         self.pos += n as u64;
 238         Ok(())
 239     }
 240
 241     #[inline]
 242     unsafe fn initializer(&self) -> Initializer {
 243         Initializer::nop()
 244     }
 245 }
 246
 247 #[stable(feature = "rust1", since = "1.0.0")]
 248 impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
 249     fn fill_buf(&mut self) -> io::Result<&[u8]> {
 250         let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
 251         Ok(&self.inner.as_ref()[(amt as usize)..])
 252     }
 253     fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
 254 }
 255
 256 // Non-resizing write implementation
 257 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
 258     let pos = cmp::min(*pos_mut, slice.len() as u64);
 259     let amt = (&mut slice[(pos as usize)..]).write(buf)?;
 260     *pos_mut += amt as u64;
 261     Ok(amt)
 262 }
 263
 264 // Resizing write implementation
 265 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
 266     let pos: usize = (*pos_mut).try_into().map_err(|_| {
 267         Error::new(ErrorKind::InvalidInput,
 268                     "cursor position exceeds maximum possible vector length")
 269     })?;
 270     // Make sure the internal buffer is as least as big as where we
 271     // currently are
 272     let len = vec.len();
 273     if len < pos {
 274         // use `resize` so that the zero filling is as efficient as possible
 275         vec.resize(pos, 0);
 276     }
 277     // Figure out what bytes will be used to overwrite what's currently
 278     // there (left), and what will be appended on the end (right)
 279     {
 280         let space = vec.len() - pos;
 281         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
 282         vec[pos..pos + left.len()].copy_from_slice(left);
 283         vec.extend_from_slice(right);
 284     }
 285
 286     // Bump us forward
 287     *pos_mut = (pos + buf.len()) as u64;
 288     Ok(buf.len())
 289 }
 290
 291 #[stable(feature = "rust1", since = "1.0.0")]
 292 impl<'a> Write for Cursor<&'a mut [u8]> {
 293     #[inline]
 294     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 295         slice_write(&mut self.pos, self.inner, buf)
 296     }
 297     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 298 }
 299
 300 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
 301 impl<'a> Write for Cursor<&'a mut Vec<u8>> {
 302     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 303         vec_write(&mut self.pos, self.inner, buf)
 304     }
 305     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 306 }
 307
 308 #[stable(feature = "rust1", since = "1.0.0")]
 309 impl Write for Cursor<Vec<u8>> {
 310     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 311         vec_write(&mut self.pos, &mut self.inner, buf)
 312     }
 313     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 314 }
 315
 316 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 317 impl Write for Cursor<Box<[u8]>> {
 318     #[inline]
 319     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 320         slice_write(&mut self.pos, &mut self.inner, buf)
 321     }
 322     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 323 }
 324
 325 #[cfg(test)]
 326 mod tests {
 327     use io::prelude::*;
 328     use io::{Cursor, SeekFrom};
 329
 330     #[test]
 331     fn test_vec_writer() {
 332         let mut writer = Vec::new();
 333         assert_eq!(writer.write(&[0]).unwrap(), 1);
 334         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 335         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 336         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 337         assert_eq!(writer, b);
 338     }
 339
 340     #[test]
 341     fn test_mem_writer() {
 342         let mut writer = Cursor::new(Vec::new());
 343         assert_eq!(writer.write(&[0]).unwrap(), 1);
 344         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 345         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 346         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 347         assert_eq!(&writer.get_ref()[..], b);
 348     }
 349
 350     #[test]
 351     fn test_mem_mut_writer() {
 352         let mut vec = Vec::new();
 353         let mut writer = Cursor::new(&mut vec);
 354         assert_eq!(writer.write(&[0]).unwrap(), 1);
 355         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 356         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 357         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 358         assert_eq!(&writer.get_ref()[..], b);
 359     }
 360
 361     #[test]
 362     fn test_box_slice_writer() {
 363         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 364         assert_eq!(writer.position(), 0);
 365         assert_eq!(writer.write(&[0]).unwrap(), 1);
 366         assert_eq!(writer.position(), 1);
 367         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 368         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 369         assert_eq!(writer.position(), 8);
 370         assert_eq!(writer.write(&[]).unwrap(), 0);
 371         assert_eq!(writer.position(), 8);
 372
 373         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 374         assert_eq!(writer.write(&[10]).unwrap(), 0);
 375         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 376         assert_eq!(&**writer.get_ref(), b);
 377     }
 378
 379     #[test]
 380     fn test_buf_writer() {
 381         let mut buf = [0 as u8; 9];
 382         {
 383             let mut writer = Cursor::new(&mut buf[..]);
 384             assert_eq!(writer.position(), 0);
 385             assert_eq!(writer.write(&[0]).unwrap(), 1);
 386             assert_eq!(writer.position(), 1);
 387             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 388             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 389             assert_eq!(writer.position(), 8);
 390             assert_eq!(writer.write(&[]).unwrap(), 0);
 391             assert_eq!(writer.position(), 8);
 392
 393             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 394             assert_eq!(writer.write(&[10]).unwrap(), 0);
 395         }
 396         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 397         assert_eq!(buf, b);
 398     }
 399
 400     #[test]
 401     fn test_buf_writer_seek() {
 402         let mut buf = [0 as u8; 8];
 403         {
 404             let mut writer = Cursor::new(&mut buf[..]);
 405             assert_eq!(writer.position(), 0);
 406             assert_eq!(writer.write(&[1]).unwrap(), 1);
 407             assert_eq!(writer.position(), 1);
 408
 409             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 410             assert_eq!(writer.position(), 2);
 411             assert_eq!(writer.write(&[2]).unwrap(), 1);
 412             assert_eq!(writer.position(), 3);
 413
 414             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 415             assert_eq!(writer.position(), 1);
 416             assert_eq!(writer.write(&[3]).unwrap(), 1);
 417             assert_eq!(writer.position(), 2);
 418
 419             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 420             assert_eq!(writer.position(), 7);
 421             assert_eq!(writer.write(&[4]).unwrap(), 1);
 422             assert_eq!(writer.position(), 8);
 423
 424         }
 425         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 426         assert_eq!(buf, b);
 427     }
 428
 429     #[test]
 430     fn test_buf_writer_error() {
 431         let mut buf = [0 as u8; 2];
 432         let mut writer = Cursor::new(&mut buf[..]);
 433         assert_eq!(writer.write(&[0]).unwrap(), 1);
 434         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 435         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 436     }
 437
 438     #[test]
 439     fn test_mem_reader() {
 440         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 441         let mut buf = [];
 442         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 443         assert_eq!(reader.position(), 0);
 444         let mut buf = [0];
 445         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 446         assert_eq!(reader.position(), 1);
 447         let b: &[_] = &[0];
 448         assert_eq!(buf, b);
 449         let mut buf = [0; 4];
 450         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 451         assert_eq!(reader.position(), 5);
 452         let b: &[_] = &[1, 2, 3, 4];
 453         assert_eq!(buf, b);
 454         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 455         let b: &[_] = &[5, 6, 7];
 456         assert_eq!(&buf[..3], b);
 457         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 458     }
 459
 460     #[test]
 461     fn test_boxed_slice_reader() {
 462         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
 463         let mut buf = [];
 464         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 465         assert_eq!(reader.position(), 0);
 466         let mut buf = [0];
 467         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 468         assert_eq!(reader.position(), 1);
 469         let b: &[_] = &[0];
 470         assert_eq!(buf, b);
 471         let mut buf = [0; 4];
 472         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 473         assert_eq!(reader.position(), 5);
 474         let b: &[_] = &[1, 2, 3, 4];
 475         assert_eq!(buf, b);
 476         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 477         let b: &[_] = &[5, 6, 7];
 478         assert_eq!(&buf[..3], b);
 479         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 480     }
 481
 482     #[test]
 483     fn read_to_end() {
 484         let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
 485         let mut v = Vec::new();
 486         reader.read_to_end(&mut v).unwrap();
 487         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 488     }
 489
 490     #[test]
 491     fn test_slice_reader() {
 492         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 493         let reader = &mut &in_buf[..];
 494         let mut buf = [];
 495         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 496         let mut buf = [0];
 497         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 498         assert_eq!(reader.len(), 7);
 499         let b: &[_] = &[0];
 500         assert_eq!(&buf[..], b);
 501         let mut buf = [0; 4];
 502         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 503         assert_eq!(reader.len(), 3);
 504         let b: &[_] = &[1, 2, 3, 4];
 505         assert_eq!(&buf[..], b);
 506         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 507         let b: &[_] = &[5, 6, 7];
 508         assert_eq!(&buf[..3], b);
 509         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 510     }
 511
 512     #[test]
 513     fn test_read_exact() {
 514         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 515         let reader = &mut &in_buf[..];
 516         let mut buf = [];
 517         assert!(reader.read_exact(&mut buf).is_ok());
 518         let mut buf = [8];
 519         assert!(reader.read_exact(&mut buf).is_ok());
 520         assert_eq!(buf[0], 0);
 521         assert_eq!(reader.len(), 7);
 522         let mut buf = [0, 0, 0, 0, 0, 0, 0];
 523         assert!(reader.read_exact(&mut buf).is_ok());
 524         assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
 525         assert_eq!(reader.len(), 0);
 526         let mut buf = [0];
 527         assert!(reader.read_exact(&mut buf).is_err());
 528     }
 529
 530     #[test]
 531     fn test_buf_reader() {
 532         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 533         let mut reader = Cursor::new(&in_buf[..]);
 534         let mut buf = [];
 535         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 536         assert_eq!(reader.position(), 0);
 537         let mut buf = [0];
 538         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 539         assert_eq!(reader.position(), 1);
 540         let b: &[_] = &[0];
 541         assert_eq!(buf, b);
 542         let mut buf = [0; 4];
 543         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 544         assert_eq!(reader.position(), 5);
 545         let b: &[_] = &[1, 2, 3, 4];
 546         assert_eq!(buf, b);
 547         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 548         let b: &[_] = &[5, 6, 7];
 549         assert_eq!(&buf[..3], b);
 550         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 551     }
 552
 553     #[test]
 554     fn seek_past_end() {
 555         let buf = [0xff];
 556         let mut r = Cursor::new(&buf[..]);
 557         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 558         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 559
 560         let mut r = Cursor::new(vec![10]);
 561         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 562         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 563
 564         let mut buf = [0];
 565         let mut r = Cursor::new(&mut buf[..]);
 566         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 567         assert_eq!(r.write(&[3]).unwrap(), 0);
 568
 569         let mut r = Cursor::new(vec![10].into_boxed_slice());
 570         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 571         assert_eq!(r.write(&[3]).unwrap(), 0);
 572     }
 573
 574     #[test]
 575     fn seek_past_i64() {
 576         let buf = [0xff];
 577         let mut r = Cursor::new(&buf[..]);
 578         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 579         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 580         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 581         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 582         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 583         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 584
 585         let mut r = Cursor::new(vec![10]);
 586         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 587         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 588         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 589         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 590         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 591         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 592
 593         let mut buf = [0];
 594         let mut r = Cursor::new(&mut buf[..]);
 595         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 596         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 597         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 598         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 599         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 600         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 601
 602         let mut r = Cursor::new(vec![10].into_boxed_slice());
 603         assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
 604         assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
 605         assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
 606         assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
 607         assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
 608         assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
 609     }
 610
 611     #[test]
 612     fn seek_before_0() {
 613         let buf = [0xff];
 614         let mut r = Cursor::new(&buf[..]);
 615         assert!(r.seek(SeekFrom::End(-2)).is_err());
 616
 617         let mut r = Cursor::new(vec![10]);
 618         assert!(r.seek(SeekFrom::End(-2)).is_err());
 619
 620         let mut buf = [0];
 621         let mut r = Cursor::new(&mut buf[..]);
 622         assert!(r.seek(SeekFrom::End(-2)).is_err());
 623
 624         let mut r = Cursor::new(vec![10].into_boxed_slice());
 625         assert!(r.seek(SeekFrom::End(-2)).is_err());
 626     }
 627
 628     #[test]
 629     fn test_seekable_mem_writer() {
 630         let mut writer = Cursor::new(Vec::<u8>::new());
 631         assert_eq!(writer.position(), 0);
 632         assert_eq!(writer.write(&[0]).unwrap(), 1);
 633         assert_eq!(writer.position(), 1);
 634         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 635         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 636         assert_eq!(writer.position(), 8);
 637         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 638         assert_eq!(&writer.get_ref()[..], b);
 639
 640         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 641         assert_eq!(writer.position(), 0);
 642         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 643         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 644         assert_eq!(&writer.get_ref()[..], b);
 645
 646         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 647         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 648         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 649         assert_eq!(&writer.get_ref()[..], b);
 650
 651         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 652         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 653         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 654         assert_eq!(&writer.get_ref()[..], b);
 655
 656         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 657         assert_eq!(writer.write(&[1]).unwrap(), 1);
 658         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 659         assert_eq!(&writer.get_ref()[..], b);
 660     }
 661
 662     #[test]
 663     fn vec_seek_past_end() {
 664         let mut r = Cursor::new(Vec::new());
 665         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 666         assert_eq!(r.write(&[3]).unwrap(), 1);
 667     }
 668
 669     #[test]
 670     fn vec_seek_before_0() {
 671         let mut r = Cursor::new(Vec::new());
 672         assert!(r.seek(SeekFrom::End(-2)).is_err());
 673     }
 674
 675     #[test]
 676     #[cfg(target_pointer_width = "32")]
 677     fn vec_seek_and_write_past_usize_max() {
 678         let mut c = Cursor::new(Vec::new());
 679         c.set_position(<usize>::max_value() as u64 + 1);
 680         assert!(c.write_all(&[1, 2, 3]).is_err());
 681     }
 682 }