1 use crate::io::prelude::*;
4 use crate::io::{self, Initializer, SeekFrom, Error, ErrorKind, IoSlice, IoSliceMut};
6 use core::convert::TryInto;
8 /// A `Cursor` wraps an in-memory buffer and provides it with a
9 /// [`Seek`] implementation.
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.
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]`>`.
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
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
34 /// use std::io::prelude::*;
35 /// use std::io::{self, SeekFrom};
36 /// use std::fs::File;
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))?;
43 /// writer.write(&[i])?;
50 /// # fn foo() -> io::Result<()> {
51 /// // Here's some code that uses this library function.
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")?;
57 /// write_ten_bytes_at_end(&mut file)?;
61 /// // now let's write a 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]);
69 /// write_ten_bytes_at_end(&mut buff).unwrap();
71 /// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
74 #[stable(feature = "rust1", since = "1.0.0")]
75 #[derive(Clone, Debug)]
76 pub struct Cursor<T> {
82 /// Creates a new cursor wrapping the provided underlying in-memory buffer.
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.
91 /// use std::io::Cursor;
93 /// let buff = Cursor::new(Vec::new());
94 /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
95 /// # force_inference(&buff);
97 #[stable(feature = "rust1", since = "1.0.0")]
98 pub fn new(inner: T) -> Cursor<T> {
99 Cursor { pos: 0, inner: inner }
102 /// Consumes this cursor, returning the underlying value.
107 /// use std::io::Cursor;
109 /// let buff = Cursor::new(Vec::new());
110 /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
111 /// # force_inference(&buff);
113 /// let vec = buff.into_inner();
115 #[stable(feature = "rust1", since = "1.0.0")]
116 pub fn into_inner(self) -> T { self.inner }
118 /// Gets a reference to the underlying value in this cursor.
123 /// use std::io::Cursor;
125 /// let buff = Cursor::new(Vec::new());
126 /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
127 /// # force_inference(&buff);
129 /// let reference = buff.get_ref();
131 #[stable(feature = "rust1", since = "1.0.0")]
132 pub fn get_ref(&self) -> &T { &self.inner }
134 /// Gets a mutable reference to the underlying value in this cursor.
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.
142 /// use std::io::Cursor;
144 /// let mut buff = Cursor::new(Vec::new());
145 /// # fn force_inference(_: &Cursor<Vec<u8>>) {}
146 /// # force_inference(&buff);
148 /// let reference = buff.get_mut();
150 #[stable(feature = "rust1", since = "1.0.0")]
151 pub fn get_mut(&mut self) -> &mut T { &mut self.inner }
153 /// Returns the current position of this cursor.
158 /// use std::io::Cursor;
159 /// use std::io::prelude::*;
160 /// use std::io::SeekFrom;
162 /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
164 /// assert_eq!(buff.position(), 0);
166 /// buff.seek(SeekFrom::Current(2)).unwrap();
167 /// assert_eq!(buff.position(), 2);
169 /// buff.seek(SeekFrom::Current(-1)).unwrap();
170 /// assert_eq!(buff.position(), 1);
172 #[stable(feature = "rust1", since = "1.0.0")]
173 pub fn position(&self) -> u64 { self.pos }
175 /// Sets the position of this cursor.
180 /// use std::io::Cursor;
182 /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
184 /// assert_eq!(buff.position(), 0);
186 /// buff.set_position(2);
187 /// assert_eq!(buff.position(), 2);
189 /// buff.set_position(4);
190 /// assert_eq!(buff.position(), 4);
192 #[stable(feature = "rust1", since = "1.0.0")]
193 pub fn set_position(&mut self, pos: u64) { self.pos = pos; }
196 #[stable(feature = "rust1", since = "1.0.0")]
197 impl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {
198 fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
199 let (base_pos, offset) = match style {
200 SeekFrom::Start(n) => { self.pos = n; return Ok(n); }
201 SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
202 SeekFrom::Current(n) => (self.pos, n),
204 let new_pos = if offset >= 0 {
205 base_pos.checked_add(offset as u64)
207 base_pos.checked_sub((offset.wrapping_neg()) as u64)
210 Some(n) => {self.pos = n; Ok(self.pos)}
211 None => Err(Error::new(ErrorKind::InvalidInput,
212 "invalid seek to a negative or overflowing position"))
216 fn stream_len(&mut self) -> io::Result<u64> {
217 Ok(self.inner.as_ref().len() as u64)
220 fn stream_position(&mut self) -> io::Result<u64> {
225 #[stable(feature = "rust1", since = "1.0.0")]
226 impl<T> Read for Cursor<T> where T: AsRef<[u8]> {
227 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
228 let n = Read::read(&mut self.fill_buf()?, buf)?;
229 self.pos += n as u64;
233 fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
236 let n = self.read(buf)?;
245 fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
247 Read::read_exact(&mut self.fill_buf()?, buf)?;
248 self.pos += n as u64;
253 unsafe fn initializer(&self) -> Initializer {
258 #[stable(feature = "rust1", since = "1.0.0")]
259 impl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {
260 fn fill_buf(&mut self) -> io::Result<&[u8]> {
261 let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
262 Ok(&self.inner.as_ref()[(amt as usize)..])
264 fn consume(&mut self, amt: usize) { self.pos += amt as u64; }
267 // Non-resizing write implementation
269 fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
270 let pos = cmp::min(*pos_mut, slice.len() as u64);
271 let amt = (&mut slice[(pos as usize)..]).write(buf)?;
272 *pos_mut += amt as u64;
277 fn slice_write_vectored(
280 bufs: &[IoSlice<'_>],
281 ) -> io::Result<usize>
283 let mut nwritten = 0;
285 let n = slice_write(pos_mut, slice, buf)?;
294 // Resizing write implementation
295 fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
296 let pos: usize = (*pos_mut).try_into().map_err(|_| {
297 Error::new(ErrorKind::InvalidInput,
298 "cursor position exceeds maximum possible vector length")
300 // Make sure the internal buffer is as least as big as where we
304 // use `resize` so that the zero filling is as efficient as possible
307 // Figure out what bytes will be used to overwrite what's currently
308 // there (left), and what will be appended on the end (right)
310 let space = vec.len() - pos;
311 let (left, right) = buf.split_at(cmp::min(space, buf.len()));
312 vec[pos..pos + left.len()].copy_from_slice(left);
313 vec.extend_from_slice(right);
317 *pos_mut = (pos + buf.len()) as u64;
321 fn vec_write_vectored(
324 bufs: &[IoSlice<'_>],
325 ) -> io::Result<usize>
327 let mut nwritten = 0;
329 nwritten += vec_write(pos_mut, vec, buf)?;
334 #[stable(feature = "rust1", since = "1.0.0")]
335 impl Write for Cursor<&mut [u8]> {
337 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
338 slice_write(&mut self.pos, self.inner, buf)
342 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
343 slice_write_vectored(&mut self.pos, self.inner, bufs)
347 fn flush(&mut self) -> io::Result<()> { Ok(()) }
350 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
351 impl Write for Cursor<&mut Vec<u8>> {
352 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
353 vec_write(&mut self.pos, self.inner, buf)
356 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
357 vec_write_vectored(&mut self.pos, self.inner, bufs)
361 fn flush(&mut self) -> io::Result<()> { Ok(()) }
364 #[stable(feature = "rust1", since = "1.0.0")]
365 impl Write for Cursor<Vec<u8>> {
366 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
367 vec_write(&mut self.pos, &mut self.inner, buf)
370 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
371 vec_write_vectored(&mut self.pos, &mut self.inner, bufs)
375 fn flush(&mut self) -> io::Result<()> { Ok(()) }
378 #[stable(feature = "cursor_box_slice", since = "1.5.0")]
379 impl Write for Cursor<Box<[u8]>> {
381 fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
382 slice_write(&mut self.pos, &mut self.inner, buf)
386 fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
387 slice_write_vectored(&mut self.pos, &mut self.inner, bufs)
391 fn flush(&mut self) -> io::Result<()> { Ok(()) }
396 use crate::io::prelude::*;
397 use crate::io::{Cursor, SeekFrom, IoSlice, IoSliceMut};
400 fn test_vec_writer() {
401 let mut writer = Vec::new();
402 assert_eq!(writer.write(&[0]).unwrap(), 1);
403 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
404 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
405 assert_eq!(writer.write_vectored(
406 &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
408 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
409 assert_eq!(writer, b);
413 fn test_mem_writer() {
414 let mut writer = Cursor::new(Vec::new());
415 assert_eq!(writer.write(&[0]).unwrap(), 1);
416 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
417 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
418 assert_eq!(writer.write_vectored(
419 &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
421 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
422 assert_eq!(&writer.get_ref()[..], b);
426 fn test_mem_mut_writer() {
427 let mut vec = Vec::new();
428 let mut writer = Cursor::new(&mut vec);
429 assert_eq!(writer.write(&[0]).unwrap(), 1);
430 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
431 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
432 assert_eq!(writer.write_vectored(
433 &[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],
435 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
436 assert_eq!(&writer.get_ref()[..], b);
440 fn test_box_slice_writer() {
441 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
442 assert_eq!(writer.position(), 0);
443 assert_eq!(writer.write(&[0]).unwrap(), 1);
444 assert_eq!(writer.position(), 1);
445 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
446 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
447 assert_eq!(writer.position(), 8);
448 assert_eq!(writer.write(&[]).unwrap(), 0);
449 assert_eq!(writer.position(), 8);
451 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
452 assert_eq!(writer.write(&[10]).unwrap(), 0);
453 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
454 assert_eq!(&**writer.get_ref(), b);
458 fn test_box_slice_writer_vectored() {
459 let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
460 assert_eq!(writer.position(), 0);
461 assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
462 assert_eq!(writer.position(), 1);
464 writer.write_vectored(&[
465 IoSlice::new(&[1, 2, 3]),
466 IoSlice::new(&[4, 5, 6, 7]),
470 assert_eq!(writer.position(), 8);
471 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
472 assert_eq!(writer.position(), 8);
474 assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
475 assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
476 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
477 assert_eq!(&**writer.get_ref(), b);
481 fn test_buf_writer() {
482 let mut buf = [0 as u8; 9];
484 let mut writer = Cursor::new(&mut buf[..]);
485 assert_eq!(writer.position(), 0);
486 assert_eq!(writer.write(&[0]).unwrap(), 1);
487 assert_eq!(writer.position(), 1);
488 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
489 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
490 assert_eq!(writer.position(), 8);
491 assert_eq!(writer.write(&[]).unwrap(), 0);
492 assert_eq!(writer.position(), 8);
494 assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
495 assert_eq!(writer.write(&[10]).unwrap(), 0);
497 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
502 fn test_buf_writer_vectored() {
503 let mut buf = [0 as u8; 9];
505 let mut writer = Cursor::new(&mut buf[..]);
506 assert_eq!(writer.position(), 0);
507 assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
508 assert_eq!(writer.position(), 1);
510 writer.write_vectored(
511 &[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],
515 assert_eq!(writer.position(), 8);
516 assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
517 assert_eq!(writer.position(), 8);
519 assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
520 assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
522 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
527 fn test_buf_writer_seek() {
528 let mut buf = [0 as u8; 8];
530 let mut writer = Cursor::new(&mut buf[..]);
531 assert_eq!(writer.position(), 0);
532 assert_eq!(writer.write(&[1]).unwrap(), 1);
533 assert_eq!(writer.position(), 1);
535 assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
536 assert_eq!(writer.position(), 2);
537 assert_eq!(writer.write(&[2]).unwrap(), 1);
538 assert_eq!(writer.position(), 3);
540 assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
541 assert_eq!(writer.position(), 1);
542 assert_eq!(writer.write(&[3]).unwrap(), 1);
543 assert_eq!(writer.position(), 2);
545 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
546 assert_eq!(writer.position(), 7);
547 assert_eq!(writer.write(&[4]).unwrap(), 1);
548 assert_eq!(writer.position(), 8);
551 let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
556 fn test_buf_writer_error() {
557 let mut buf = [0 as u8; 2];
558 let mut writer = Cursor::new(&mut buf[..]);
559 assert_eq!(writer.write(&[0]).unwrap(), 1);
560 assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
561 assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
565 fn test_mem_reader() {
566 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
568 assert_eq!(reader.read(&mut buf).unwrap(), 0);
569 assert_eq!(reader.position(), 0);
571 assert_eq!(reader.read(&mut buf).unwrap(), 1);
572 assert_eq!(reader.position(), 1);
575 let mut buf = [0; 4];
576 assert_eq!(reader.read(&mut buf).unwrap(), 4);
577 assert_eq!(reader.position(), 5);
578 let b: &[_] = &[1, 2, 3, 4];
580 assert_eq!(reader.read(&mut buf).unwrap(), 3);
581 let b: &[_] = &[5, 6, 7];
582 assert_eq!(&buf[..3], b);
583 assert_eq!(reader.read(&mut buf).unwrap(), 0);
587 fn test_mem_reader_vectored() {
588 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
590 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
591 assert_eq!(reader.position(), 0);
594 reader.read_vectored(&mut [
595 IoSliceMut::new(&mut []),
596 IoSliceMut::new(&mut buf),
600 assert_eq!(reader.position(), 1);
603 let mut buf1 = [0; 4];
604 let mut buf2 = [0; 4];
606 reader.read_vectored(&mut [
607 IoSliceMut::new(&mut buf1),
608 IoSliceMut::new(&mut buf2),
612 let b1: &[_] = &[1, 2, 3, 4];
613 let b2: &[_] = &[5, 6, 7];
614 assert_eq!(buf1, b1);
615 assert_eq!(&buf2[..3], b2);
616 assert_eq!(reader.read(&mut buf).unwrap(), 0);
620 fn test_boxed_slice_reader() {
621 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
623 assert_eq!(reader.read(&mut buf).unwrap(), 0);
624 assert_eq!(reader.position(), 0);
626 assert_eq!(reader.read(&mut buf).unwrap(), 1);
627 assert_eq!(reader.position(), 1);
630 let mut buf = [0; 4];
631 assert_eq!(reader.read(&mut buf).unwrap(), 4);
632 assert_eq!(reader.position(), 5);
633 let b: &[_] = &[1, 2, 3, 4];
635 assert_eq!(reader.read(&mut buf).unwrap(), 3);
636 let b: &[_] = &[5, 6, 7];
637 assert_eq!(&buf[..3], b);
638 assert_eq!(reader.read(&mut buf).unwrap(), 0);
642 fn test_boxed_slice_reader_vectored() {
643 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
645 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
646 assert_eq!(reader.position(), 0);
649 reader.read_vectored(&mut [
650 IoSliceMut::new(&mut []),
651 IoSliceMut::new(&mut buf),
655 assert_eq!(reader.position(), 1);
658 let mut buf1 = [0; 4];
659 let mut buf2 = [0; 4];
661 reader.read_vectored(
662 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
666 let b1: &[_] = &[1, 2, 3, 4];
667 let b2: &[_] = &[5, 6, 7];
668 assert_eq!(buf1, b1);
669 assert_eq!(&buf2[..3], b2);
670 assert_eq!(reader.read(&mut buf).unwrap(), 0);
675 let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
676 let mut v = Vec::new();
677 reader.read_to_end(&mut v).unwrap();
678 assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
682 fn test_slice_reader() {
683 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
684 let reader = &mut &in_buf[..];
686 assert_eq!(reader.read(&mut buf).unwrap(), 0);
688 assert_eq!(reader.read(&mut buf).unwrap(), 1);
689 assert_eq!(reader.len(), 7);
691 assert_eq!(&buf[..], b);
692 let mut buf = [0; 4];
693 assert_eq!(reader.read(&mut buf).unwrap(), 4);
694 assert_eq!(reader.len(), 3);
695 let b: &[_] = &[1, 2, 3, 4];
696 assert_eq!(&buf[..], b);
697 assert_eq!(reader.read(&mut buf).unwrap(), 3);
698 let b: &[_] = &[5, 6, 7];
699 assert_eq!(&buf[..3], b);
700 assert_eq!(reader.read(&mut buf).unwrap(), 0);
704 fn test_slice_reader_vectored() {
705 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
706 let reader = &mut &in_buf[..];
708 assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
711 reader.read_vectored(&mut [
712 IoSliceMut::new(&mut []),
713 IoSliceMut::new(&mut buf),
717 assert_eq!(reader.len(), 7);
720 let mut buf1 = [0; 4];
721 let mut buf2 = [0; 4];
723 reader.read_vectored(
724 &mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],
728 let b1: &[_] = &[1, 2, 3, 4];
729 let b2: &[_] = &[5, 6, 7];
730 assert_eq!(buf1, b1);
731 assert_eq!(&buf2[..3], b2);
732 assert_eq!(reader.read(&mut buf).unwrap(), 0);
736 fn test_read_exact() {
737 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
738 let reader = &mut &in_buf[..];
740 assert!(reader.read_exact(&mut buf).is_ok());
742 assert!(reader.read_exact(&mut buf).is_ok());
743 assert_eq!(buf[0], 0);
744 assert_eq!(reader.len(), 7);
745 let mut buf = [0, 0, 0, 0, 0, 0, 0];
746 assert!(reader.read_exact(&mut buf).is_ok());
747 assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
748 assert_eq!(reader.len(), 0);
750 assert!(reader.read_exact(&mut buf).is_err());
754 fn test_buf_reader() {
755 let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
756 let mut reader = Cursor::new(&in_buf[..]);
758 assert_eq!(reader.read(&mut buf).unwrap(), 0);
759 assert_eq!(reader.position(), 0);
761 assert_eq!(reader.read(&mut buf).unwrap(), 1);
762 assert_eq!(reader.position(), 1);
765 let mut buf = [0; 4];
766 assert_eq!(reader.read(&mut buf).unwrap(), 4);
767 assert_eq!(reader.position(), 5);
768 let b: &[_] = &[1, 2, 3, 4];
770 assert_eq!(reader.read(&mut buf).unwrap(), 3);
771 let b: &[_] = &[5, 6, 7];
772 assert_eq!(&buf[..3], b);
773 assert_eq!(reader.read(&mut buf).unwrap(), 0);
779 let mut r = Cursor::new(&buf[..]);
780 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
781 assert_eq!(r.read(&mut [0]).unwrap(), 0);
783 let mut r = Cursor::new(vec![10]);
784 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
785 assert_eq!(r.read(&mut [0]).unwrap(), 0);
788 let mut r = Cursor::new(&mut buf[..]);
789 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
790 assert_eq!(r.write(&[3]).unwrap(), 0);
792 let mut r = Cursor::new(vec![10].into_boxed_slice());
793 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
794 assert_eq!(r.write(&[3]).unwrap(), 0);
800 let mut r = Cursor::new(&buf[..]);
801 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
802 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
803 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
804 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
805 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
806 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
808 let mut r = Cursor::new(vec![10]);
809 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
810 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
811 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
812 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
813 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
814 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
817 let mut r = Cursor::new(&mut buf[..]);
818 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
819 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
820 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
821 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
822 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
823 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
825 let mut r = Cursor::new(vec![10].into_boxed_slice());
826 assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
827 assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
828 assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
829 assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
830 assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
831 assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
837 let mut r = Cursor::new(&buf[..]);
838 assert!(r.seek(SeekFrom::End(-2)).is_err());
840 let mut r = Cursor::new(vec![10]);
841 assert!(r.seek(SeekFrom::End(-2)).is_err());
844 let mut r = Cursor::new(&mut buf[..]);
845 assert!(r.seek(SeekFrom::End(-2)).is_err());
847 let mut r = Cursor::new(vec![10].into_boxed_slice());
848 assert!(r.seek(SeekFrom::End(-2)).is_err());
852 fn test_seekable_mem_writer() {
853 let mut writer = Cursor::new(Vec::<u8>::new());
854 assert_eq!(writer.position(), 0);
855 assert_eq!(writer.write(&[0]).unwrap(), 1);
856 assert_eq!(writer.position(), 1);
857 assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
858 assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
859 assert_eq!(writer.position(), 8);
860 let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
861 assert_eq!(&writer.get_ref()[..], b);
863 assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
864 assert_eq!(writer.position(), 0);
865 assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
866 let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
867 assert_eq!(&writer.get_ref()[..], b);
869 assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
870 assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
871 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
872 assert_eq!(&writer.get_ref()[..], b);
874 assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
875 assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
876 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
877 assert_eq!(&writer.get_ref()[..], b);
879 assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
880 assert_eq!(writer.write(&[1]).unwrap(), 1);
881 let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
882 assert_eq!(&writer.get_ref()[..], b);
886 fn vec_seek_past_end() {
887 let mut r = Cursor::new(Vec::new());
888 assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
889 assert_eq!(r.write(&[3]).unwrap(), 1);
893 fn vec_seek_before_0() {
894 let mut r = Cursor::new(Vec::new());
895 assert!(r.seek(SeekFrom::End(-2)).is_err());
899 #[cfg(target_pointer_width = "32")]
900 fn vec_seek_and_write_past_usize_max() {
901 let mut c = Cursor::new(Vec::new());
902 c.set_position(<usize>::max_value() as u64 + 1);
903 assert!(c.write_all(&[1, 2, 3]).is_err());