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 cmp;
  14 use io::{self, SeekFrom, Error, ErrorKind};
  15
  16 /// A `Cursor` wraps another type and provides it with a
  17 /// [`Seek`](trait.Seek.html) implementation.
  18 ///
  19 /// Cursors are typically used with in-memory buffers to allow them to
  20 /// implement `Read` and/or `Write`, allowing these buffers to be used
  21 /// anywhere you might use a reader or writer that does actual I/O.
  22 ///
  23 /// The standard library implements some I/O traits on various types which
  24 /// are commonly used as a buffer, like `Cursor<Vec<u8>>` and `Cursor<&[u8]>`.
  25 ///
  26 /// # Examples
  27 ///
  28 /// We may want to write bytes to a [`File`][file] in our production
  29 /// code, but use an in-memory buffer in our tests. We can do this with
  30 /// `Cursor`:
  31 ///
  32 /// [file]: ../fs/struct.File.html
  33 ///
  34 /// ```no_run
  35 /// use std::io::prelude::*;
  36 /// use std::io::{self, SeekFrom};
  37 /// use std::fs::File;
  38 ///
  39 /// // a library function we've written
  40 /// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
  41 ///     try!(writer.seek(SeekFrom::End(-10)));
  42 ///
  43 ///     for i in 0..10 {
  44 ///         try!(writer.write(&[i]));
  45 ///     }
  46 ///
  47 ///     // all went well
  48 ///     Ok(())
  49 /// }
  50 ///
  51 /// # fn foo() -> io::Result<()> {
  52 /// // Here's some code that uses this library function.
  53 /// //
  54 /// // We might want to use a BufReader here for efficiency, but let's
  55 /// // keep this example focused.
  56 /// let mut file = try!(File::create("foo.txt"));
  57 ///
  58 /// try!(write_ten_bytes_at_end(&mut file));
  59 /// # Ok(())
  60 /// # }
  61 ///
  62 /// // now let's write a test
  63 /// #[test]
  64 /// fn test_writes_bytes() {
  65 ///     // setting up a real File is much more slow than an in-memory buffer,
  66 ///     // let's use a cursor instead
  67 ///     use std::io::Cursor;
  68 ///     let mut buff = Cursor::new(vec![0; 15]);
  69 ///
  70 ///     write_ten_bytes_at_end(&mut buff).unwrap();
  71 ///
  72 ///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
  73 /// }
  74 /// ```
  75 #[stable(feature = "rust1", since = "1.0.0")]
  76 #[derive(Clone, Debug)]
  77 pub struct Cursor<T> {
  78     inner: T,
  79     pos: u64,
  80 }
  81
  82 impl<T> Cursor<T> {
  83     /// Creates a new cursor wrapping the provided underlying I/O object.
  84     ///
  85     /// # Examples
  86     ///
  87     /// ```
  88     /// use std::io::Cursor;
  89     ///
  90     /// let buff = Cursor::new(Vec::new());
  91     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
  92     /// # force_inference(&buff);
  93     /// ```
  94     #[stable(feature = "rust1", since = "1.0.0")]
  95     pub fn new(inner: T) -> Cursor<T> {
  96         Cursor { pos: 0, inner: inner }
  97     }
  98
  99     /// Consumes this cursor, returning the underlying value.
 100     ///
 101     /// # Examples
 102     ///
 103     /// ```
 104     /// use std::io::Cursor;
 105     ///
 106     /// let buff = Cursor::new(Vec::new());
 107     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 108     /// # force_inference(&buff);
 109     ///
 110     /// let vec = buff.into_inner();
 111     /// ```
 112     #[stable(feature = "rust1", since = "1.0.0")]
 113     pub fn into_inner(self) -> T { self.inner }
 114
 115     /// Gets a reference to the underlying value in this cursor.
 116     ///
 117     /// # Examples
 118     ///
 119     /// ```
 120     /// use std::io::Cursor;
 121     ///
 122     /// let buff = Cursor::new(Vec::new());
 123     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 124     /// # force_inference(&buff);
 125     ///
 126     /// let reference = buff.get_ref();
 127     /// ```
 128     #[stable(feature = "rust1", since = "1.0.0")]
 129     pub fn get_ref(&self) -> &T { &self.inner }
 130
 131     /// Gets a mutable reference to the underlying value in this cursor.
 132     ///
 133     /// Care should be taken to avoid modifying the internal I/O state of the
 134     /// underlying value as it may corrupt this cursor's position.
 135     ///
 136     /// # Examples
 137     ///
 138     /// ```
 139     /// use std::io::Cursor;
 140     ///
 141     /// let mut buff = Cursor::new(Vec::new());
 142     /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
 143     /// # force_inference(&buff);
 144     ///
 145     /// let reference = buff.get_mut();
 146     /// ```
 147     #[stable(feature = "rust1", since = "1.0.0")]
 148     pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
 149
 150     /// Returns the current position of this cursor.
 151     ///
 152     /// # Examples
 153     ///
 154     /// ```
 155     /// use std::io::Cursor;
 156     /// use std::io::prelude::*;
 157     /// use std::io::SeekFrom;
 158     ///
 159     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 160     ///
 161     /// assert_eq!(buff.position(), 0);
 162     ///
 163     /// buff.seek(SeekFrom::Current(2)).unwrap();
 164     /// assert_eq!(buff.position(), 2);
 165     ///
 166     /// buff.seek(SeekFrom::Current(-1)).unwrap();
 167     /// assert_eq!(buff.position(), 1);
 168     /// ```
 169     #[stable(feature = "rust1", since = "1.0.0")]
 170     pub fn position(&self) -> u64 { self.pos }
 171
 172     /// Sets the position of this cursor.
 173     ///
 174     /// # Examples
 175     ///
 176     /// ```
 177     /// use std::io::Cursor;
 178     ///
 179     /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
 180     ///
 181     /// assert_eq!(buff.position(), 0);
 182     ///
 183     /// buff.set_position(2);
 184     /// assert_eq!(buff.position(), 2);
 185     ///
 186     /// buff.set_position(4);
 187     /// assert_eq!(buff.position(), 4);
 188     /// ```
 189     #[stable(feature = "rust1", since = "1.0.0")]
 190     pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
 191 }
 192
 193 #[stable(feature = "rust1", since = "1.0.0")]
 194 impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
 195     fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
 196         let pos = match style {
 197             SeekFrom::Start(n) => { self.pos = n; return Ok(n) }
 198             SeekFrom::End(n) => self.inner.as_ref().len() as i64 + n,
 199             SeekFrom::Current(n) => self.pos as i64 + n,
 200         };
 201
 202         if pos < 0 {
 203             Err(Error::new(ErrorKind::InvalidInput,
 204                            "invalid seek to a negative position"))
 205         } else {
 206             self.pos = pos as u64;
 207             Ok(self.pos)
 208         }
 209     }
 210 }
 211
 212 #[stable(feature = "rust1", since = "1.0.0")]
 213 impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
 214     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
 215         let n = Read::read(&mut self.fill_buf()?, buf)?;
 216         self.pos += n as u64;
 217         Ok(n)
 218     }
 219 }
 220
 221 #[stable(feature = "rust1", since = "1.0.0")]
 222 impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
 223     fn fill_buf(&mut self) -> io::Result<&[u8]> {
 224         let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
 225         Ok(&self.inner.as_ref()[(amt as usize)..])
 226     }
 227     fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
 228 }
 229
 230 #[stable(feature = "rust1", since = "1.0.0")]
 231 impl<'a> Write for Cursor<&'a mut [u8]> {
 232     #[inline]
 233     fn write(&mut self, data: &[u8]) -> io::Result<usize> {
 234         let pos = cmp::min(self.pos, self.inner.len() as u64);
 235         let amt = (&mut self.inner[(pos as usize)..]).write(data)?;
 236         self.pos += amt as u64;
 237         Ok(amt)
 238     }
 239     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 240 }
 241
 242 #[stable(feature = "rust1", since = "1.0.0")]
 243 impl Write for Cursor<Vec<u8>> {
 244     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 245         // Make sure the internal buffer is as least as big as where we
 246         // currently are
 247         let pos = self.position();
 248         let amt = pos.saturating_sub(self.inner.len() as u64);
 249         // use `resize` so that the zero filling is as efficient as possible
 250         let len = self.inner.len();
 251         self.inner.resize(len + amt as usize, 0);
 252
 253         // Figure out what bytes will be used to overwrite what's currently
 254         // there (left), and what will be appended on the end (right)
 255         {
 256             let pos = pos as usize;
 257             let space = self.inner.len() - pos;
 258             let (left, right) = buf.split_at(cmp::min(space, buf.len()));
 259             self.inner[pos..pos + left.len()].copy_from_slice(left);
 260             self.inner.extend_from_slice(right);
 261         }
 262
 263         // Bump us forward
 264         self.set_position(pos + buf.len() as u64);
 265         Ok(buf.len())
 266     }
 267     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 268 }
 269
 270 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
 271 impl Write for Cursor<Box<[u8]>> {
 272     #[inline]
 273     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
 274         let pos = cmp::min(self.pos, self.inner.len() as u64);
 275         let amt = (&mut self.inner[(pos as usize)..]).write(buf)?;
 276         self.pos += amt as u64;
 277         Ok(amt)
 278     }
 279     fn flush(&mut self) -> io::Result<()> { Ok(()) }
 280 }
 281
 282 #[cfg(test)]
 283 mod tests {
 284     use io::prelude::*;
 285     use io::{Cursor, SeekFrom};
 286
 287     #[test]
 288     fn test_vec_writer() {
 289         let mut writer = Vec::new();
 290         assert_eq!(writer.write(&[0]).unwrap(), 1);
 291         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 292         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 293         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 294         assert_eq!(writer, b);
 295     }
 296
 297     #[test]
 298     fn test_mem_writer() {
 299         let mut writer = Cursor::new(Vec::new());
 300         assert_eq!(writer.write(&[0]).unwrap(), 1);
 301         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 302         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 303         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 304         assert_eq!(&writer.get_ref()[..], b);
 305     }
 306
 307     #[test]
 308     fn test_box_slice_writer() {
 309         let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
 310         assert_eq!(writer.position(), 0);
 311         assert_eq!(writer.write(&[0]).unwrap(), 1);
 312         assert_eq!(writer.position(), 1);
 313         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 314         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 315         assert_eq!(writer.position(), 8);
 316         assert_eq!(writer.write(&[]).unwrap(), 0);
 317         assert_eq!(writer.position(), 8);
 318
 319         assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 320         assert_eq!(writer.write(&[10]).unwrap(), 0);
 321         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 322         assert_eq!(&**writer.get_ref(), b);
 323     }
 324
 325     #[test]
 326     fn test_buf_writer() {
 327         let mut buf = [0 as u8; 9];
 328         {
 329             let mut writer = Cursor::new(&mut buf[..]);
 330             assert_eq!(writer.position(), 0);
 331             assert_eq!(writer.write(&[0]).unwrap(), 1);
 332             assert_eq!(writer.position(), 1);
 333             assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 334             assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 335             assert_eq!(writer.position(), 8);
 336             assert_eq!(writer.write(&[]).unwrap(), 0);
 337             assert_eq!(writer.position(), 8);
 338
 339             assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
 340             assert_eq!(writer.write(&[10]).unwrap(), 0);
 341         }
 342         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
 343         assert_eq!(buf, b);
 344     }
 345
 346     #[test]
 347     fn test_buf_writer_seek() {
 348         let mut buf = [0 as u8; 8];
 349         {
 350             let mut writer = Cursor::new(&mut buf[..]);
 351             assert_eq!(writer.position(), 0);
 352             assert_eq!(writer.write(&[1]).unwrap(), 1);
 353             assert_eq!(writer.position(), 1);
 354
 355             assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
 356             assert_eq!(writer.position(), 2);
 357             assert_eq!(writer.write(&[2]).unwrap(), 1);
 358             assert_eq!(writer.position(), 3);
 359
 360             assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
 361             assert_eq!(writer.position(), 1);
 362             assert_eq!(writer.write(&[3]).unwrap(), 1);
 363             assert_eq!(writer.position(), 2);
 364
 365             assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 366             assert_eq!(writer.position(), 7);
 367             assert_eq!(writer.write(&[4]).unwrap(), 1);
 368             assert_eq!(writer.position(), 8);
 369
 370         }
 371         let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
 372         assert_eq!(buf, b);
 373     }
 374
 375     #[test]
 376     fn test_buf_writer_error() {
 377         let mut buf = [0 as u8; 2];
 378         let mut writer = Cursor::new(&mut buf[..]);
 379         assert_eq!(writer.write(&[0]).unwrap(), 1);
 380         assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
 381         assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
 382     }
 383
 384     #[test]
 385     fn test_mem_reader() {
 386         let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
 387         let mut buf = [];
 388         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 389         assert_eq!(reader.position(), 0);
 390         let mut buf = [0];
 391         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 392         assert_eq!(reader.position(), 1);
 393         let b: &[_] = &[0];
 394         assert_eq!(buf, b);
 395         let mut buf = [0; 4];
 396         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 397         assert_eq!(reader.position(), 5);
 398         let b: &[_] = &[1, 2, 3, 4];
 399         assert_eq!(buf, b);
 400         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 401         let b: &[_] = &[5, 6, 7];
 402         assert_eq!(&buf[..3], b);
 403         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 404     }
 405
 406     #[test]
 407     fn test_boxed_slice_reader() {
 408         let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7).into_boxed_slice());
 409         let mut buf = [];
 410         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 411         assert_eq!(reader.position(), 0);
 412         let mut buf = [0];
 413         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 414         assert_eq!(reader.position(), 1);
 415         let b: &[_] = &[0];
 416         assert_eq!(buf, b);
 417         let mut buf = [0; 4];
 418         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 419         assert_eq!(reader.position(), 5);
 420         let b: &[_] = &[1, 2, 3, 4];
 421         assert_eq!(buf, b);
 422         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 423         let b: &[_] = &[5, 6, 7];
 424         assert_eq!(&buf[..3], b);
 425         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 426     }
 427
 428     #[test]
 429     fn read_to_end() {
 430         let mut reader = Cursor::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
 431         let mut v = Vec::new();
 432         reader.read_to_end(&mut v).unwrap();
 433         assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
 434     }
 435
 436     #[test]
 437     fn test_slice_reader() {
 438         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 439         let mut reader = &mut &in_buf[..];
 440         let mut buf = [];
 441         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 442         let mut buf = [0];
 443         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 444         assert_eq!(reader.len(), 7);
 445         let b: &[_] = &[0];
 446         assert_eq!(&buf[..], b);
 447         let mut buf = [0; 4];
 448         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 449         assert_eq!(reader.len(), 3);
 450         let b: &[_] = &[1, 2, 3, 4];
 451         assert_eq!(&buf[..], b);
 452         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 453         let b: &[_] = &[5, 6, 7];
 454         assert_eq!(&buf[..3], b);
 455         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 456     }
 457
 458     #[test]
 459     fn test_buf_reader() {
 460         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
 461         let mut reader = Cursor::new(&in_buf[..]);
 462         let mut buf = [];
 463         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 464         assert_eq!(reader.position(), 0);
 465         let mut buf = [0];
 466         assert_eq!(reader.read(&mut buf).unwrap(), 1);
 467         assert_eq!(reader.position(), 1);
 468         let b: &[_] = &[0];
 469         assert_eq!(buf, b);
 470         let mut buf = [0; 4];
 471         assert_eq!(reader.read(&mut buf).unwrap(), 4);
 472         assert_eq!(reader.position(), 5);
 473         let b: &[_] = &[1, 2, 3, 4];
 474         assert_eq!(buf, b);
 475         assert_eq!(reader.read(&mut buf).unwrap(), 3);
 476         let b: &[_] = &[5, 6, 7];
 477         assert_eq!(&buf[..3], b);
 478         assert_eq!(reader.read(&mut buf).unwrap(), 0);
 479     }
 480
 481     #[test]
 482     fn test_read_char() {
 483         let b = &b"Vi\xE1\xBB\x87t"[..];
 484         let mut c = Cursor::new(b).chars();
 485         assert_eq!(c.next().unwrap().unwrap(), 'V');
 486         assert_eq!(c.next().unwrap().unwrap(), 'i');
 487         assert_eq!(c.next().unwrap().unwrap(), 'ệ');
 488         assert_eq!(c.next().unwrap().unwrap(), 't');
 489         assert!(c.next().is_none());
 490     }
 491
 492     #[test]
 493     fn test_read_bad_char() {
 494         let b = &b"\x80"[..];
 495         let mut c = Cursor::new(b).chars();
 496         assert!(c.next().unwrap().is_err());
 497     }
 498
 499     #[test]
 500     fn seek_past_end() {
 501         let buf = [0xff];
 502         let mut r = Cursor::new(&buf[..]);
 503         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 504         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 505
 506         let mut r = Cursor::new(vec!(10));
 507         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 508         assert_eq!(r.read(&mut [0]).unwrap(), 0);
 509
 510         let mut buf = [0];
 511         let mut r = Cursor::new(&mut buf[..]);
 512         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 513         assert_eq!(r.write(&[3]).unwrap(), 0);
 514
 515         let mut r = Cursor::new(vec![10].into_boxed_slice());
 516         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 517         assert_eq!(r.write(&[3]).unwrap(), 0);
 518     }
 519
 520     #[test]
 521     fn seek_before_0() {
 522         let buf = [0xff];
 523         let mut r = Cursor::new(&buf[..]);
 524         assert!(r.seek(SeekFrom::End(-2)).is_err());
 525
 526         let mut r = Cursor::new(vec!(10));
 527         assert!(r.seek(SeekFrom::End(-2)).is_err());
 528
 529         let mut buf = [0];
 530         let mut r = Cursor::new(&mut buf[..]);
 531         assert!(r.seek(SeekFrom::End(-2)).is_err());
 532
 533         let mut r = Cursor::new(vec!(10).into_boxed_slice());
 534         assert!(r.seek(SeekFrom::End(-2)).is_err());
 535     }
 536
 537     #[test]
 538     fn test_seekable_mem_writer() {
 539         let mut writer = Cursor::new(Vec::<u8>::new());
 540         assert_eq!(writer.position(), 0);
 541         assert_eq!(writer.write(&[0]).unwrap(), 1);
 542         assert_eq!(writer.position(), 1);
 543         assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
 544         assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
 545         assert_eq!(writer.position(), 8);
 546         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
 547         assert_eq!(&writer.get_ref()[..], b);
 548
 549         assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
 550         assert_eq!(writer.position(), 0);
 551         assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
 552         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
 553         assert_eq!(&writer.get_ref()[..], b);
 554
 555         assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
 556         assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
 557         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
 558         assert_eq!(&writer.get_ref()[..], b);
 559
 560         assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
 561         assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
 562         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
 563         assert_eq!(&writer.get_ref()[..], b);
 564
 565         assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
 566         assert_eq!(writer.write(&[1]).unwrap(), 1);
 567         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
 568         assert_eq!(&writer.get_ref()[..], b);
 569     }
 570
 571     #[test]
 572     fn vec_seek_past_end() {
 573         let mut r = Cursor::new(Vec::new());
 574         assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
 575         assert_eq!(r.write(&[3]).unwrap(), 1);
 576     }
 577
 578     #[test]
 579     fn vec_seek_before_0() {
 580         let mut r = Cursor::new(Vec::new());
 581         assert!(r.seek(SeekFrom::End(-2)).is_err());
 582     }
 583 }