forked from M-Labs/zynq-rs
897 lines
28 KiB
Rust
897 lines
28 KiB
Rust
|
use crate::io::prelude::*;
|
||
|
|
|
||
|
|
use core::cmp;
|
||
|
|
use crate::io::{self, Error, ErrorKind, Initializer, SeekFrom};
|
||
|
|
|
||
|
|
#[cfg(feature = "collections")]
|
||
|
|
use core::convert::TryInto;
|
||
|
|
|
||
|
|
#[cfg(feature="collections")]
|
||
|
|
use collections::vec::Vec;
|
||
|
|
|
||
|
|
#[cfg(feature = "alloc")]
|
||
|
|
use alloc::boxed::Box;
|
||
|
|
|
||
|
|
/// A `Cursor` wraps an in-memory buffer and provides it with a
|
||
|
|
/// [`Seek`] implementation.
|
||
|
|
///
|
||
|
|
/// `Cursor`s are used with in-memory buffers, anything implementing
|
||
|
|
/// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
|
||
|
|
/// allowing these buffers to be used anywhere you might use a reader or writer
|
||
|
|
/// that does actual I/O.
|
||
|
|
///
|
||
|
|
/// The standard library implements some I/O traits on various types which
|
||
|
|
/// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
|
||
|
|
/// `Cursor<`[`&[u8]`][bytes]`>`.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// We may want to write bytes to a [`File`] in our production
|
||
|
|
/// code, but use an in-memory buffer in our tests. We can do this with
|
||
|
|
/// `Cursor`:
|
||
|
|
///
|
||
|
|
/// [`Seek`]: trait.Seek.html
|
||
|
|
/// [`Read`]: ../../std/io/trait.Read.html
|
||
|
|
/// [`Write`]: ../../std/io/trait.Write.html
|
||
|
|
/// [`Vec`]: ../../std/vec/struct.Vec.html
|
||
|
|
/// [bytes]: ../../std/primitive.slice.html
|
||
|
|
/// [`File`]: ../fs/struct.File.html
|
||
|
|
///
|
||
|
|
/// ```no_run
|
||
|
|
/// use std::io::prelude::*;
|
||
|
|
/// use std::io::{self, SeekFrom};
|
||
|
|
/// use std::fs::File;
|
||
|
|
///
|
||
|
|
/// // a library function we've written
|
||
|
|
/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
|
||
|
|
/// writer.seek(SeekFrom::End(-10))?;
|
||
|
|
///
|
||
|
|
/// for i in 0..10 {
|
||
|
|
/// writer.write(&[i])?;
|
||
|
|
/// }
|
||
|
|
///
|
||
|
|
/// // all went well
|
||
|
|
/// Ok(())
|
||
|
|
/// }
|
||
|
|
///
|
||
|
|
/// # fn foo() -> io::Result<()> {
|
||
|
|
/// // Here's some code that uses this library function.
|
||
|
|
/// //
|
||
|
|
/// // We might want to use a BufReader here for efficiency, but let's
|
||
|
|
/// // keep this example focused.
|
||
|
|
/// let mut file = File::create("foo.txt")?;
|
||
|
|
///
|
||
|
|
/// write_ten_bytes_at_end(&mut file)?;
|
||
|
|
/// # Ok(())
|
||
|
|
/// # }
|
||
|
|
///
|
||
|
|
/// // now let's write a test
|
||
|
|
/// #[test]
|
||
|
|
/// fn test_writes_bytes() {
|
||
|
|
/// // setting up a real File is much slower than an in-memory buffer,
|
||
|
|
/// // let's use a cursor instead
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
/// let mut buff = Cursor::new(vec![0; 15]);
|
||
|
|
///
|
||
|
|
/// write_ten_bytes_at_end(&mut buff).unwrap();
|
||
|
|
///
|
||
|
|
/// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||
|
|
/// }
|
||
|
|
/// ```
|
||
|
|
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||
|
|
pub struct Cursor<T> {
|
||
|
|
inner: T,
|
||
|
|
pos: u64,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<T> Cursor<T> {
|
||
|
|
/// Creates a new cursor wrapping the provided underlying in-memory buffer.
|
||
|
|
///
|
||
|
|
/// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
|
||
|
|
/// is not empty. So writing to cursor starts with overwriting `Vec`
|
||
|
|
/// content, not with appending to it.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
///
|
||
|
|
/// let buff = Cursor::new(Vec::new());
|
||
|
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||
|
|
/// # force_inference(&buff);
|
||
|
|
/// ```
|
||
|
|
pub fn new(inner: T) -> Cursor<T> {
|
||
|
|
Cursor { pos: 0, inner }
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Consumes this cursor, returning the underlying value.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
///
|
||
|
|
/// let buff = Cursor::new(Vec::new());
|
||
|
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||
|
|
/// # force_inference(&buff);
|
||
|
|
///
|
||
|
|
/// let vec = buff.into_inner();
|
||
|
|
/// ```
|
||
|
|
pub fn into_inner(self) -> T {
|
||
|
|
self.inner
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Gets a reference to the underlying value in this cursor.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
///
|
||
|
|
/// let buff = Cursor::new(Vec::new());
|
||
|
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||
|
|
/// # force_inference(&buff);
|
||
|
|
///
|
||
|
|
/// let reference = buff.get_ref();
|
||
|
|
/// ```
|
||
|
|
pub fn get_ref(&self) -> &T {
|
||
|
|
&self.inner
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Gets a mutable reference to the underlying value in this cursor.
|
||
|
|
///
|
||
|
|
/// Care should be taken to avoid modifying the internal I/O state of the
|
||
|
|
/// underlying value as it may corrupt this cursor's position.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
///
|
||
|
|
/// let mut buff = Cursor::new(Vec::new());
|
||
|
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||
|
|
/// # force_inference(&buff);
|
||
|
|
///
|
||
|
|
/// let reference = buff.get_mut();
|
||
|
|
/// ```
|
||
|
|
pub fn get_mut(&mut self) -> &mut T {
|
||
|
|
&mut self.inner
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Returns the current position of this cursor.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
/// use std::io::prelude::*;
|
||
|
|
/// use std::io::SeekFrom;
|
||
|
|
///
|
||
|
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||
|
|
///
|
||
|
|
/// assert_eq!(buff.position(), 0);
|
||
|
|
///
|
||
|
|
/// buff.seek(SeekFrom::Current(2)).unwrap();
|
||
|
|
/// assert_eq!(buff.position(), 2);
|
||
|
|
///
|
||
|
|
/// buff.seek(SeekFrom::Current(-1)).unwrap();
|
||
|
|
/// assert_eq!(buff.position(), 1);
|
||
|
|
/// ```
|
||
|
|
pub fn position(&self) -> u64 {
|
||
|
|
self.pos
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Sets the position of this cursor.
|
||
|
|
///
|
||
|
|
/// # Examples
|
||
|
|
///
|
||
|
|
/// ```
|
||
|
|
/// use std::io::Cursor;
|
||
|
|
///
|
||
|
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||
|
|
///
|
||
|
|
/// assert_eq!(buff.position(), 0);
|
||
|
|
///
|
||
|
|
/// buff.set_position(2);
|
||
|
|
/// assert_eq!(buff.position(), 2);
|
||
|
|
///
|
||
|
|
/// buff.set_position(4);
|
||
|
|
/// assert_eq!(buff.position(), 4);
|
||
|
|
/// ```
|
||
|
|
pub fn set_position(&mut self, pos: u64) {
|
||
|
|
self.pos = pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<T> io::Seek for Cursor<T>
|
||
|
|
where
|
||
|
|
T: AsRef<[u8]>,
|
||
|
|
{
|
||
|
|
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
|
||
|
|
let (base_pos, offset) = match style {
|
||
|
|
SeekFrom::Start(n) => {
|
||
|
|
self.pos = n;
|
||
|
|
return Ok(n);
|
||
|
|
}
|
||
|
|
SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
|
||
|
|
SeekFrom::Current(n) => (self.pos, n),
|
||
|
|
};
|
||
|
|
let new_pos = if offset >= 0 {
|
||
|
|
base_pos.checked_add(offset as u64)
|
||
|
|
} else {
|
||
|
|
base_pos.checked_sub((offset.wrapping_neg()) as u64)
|
||
|
|
};
|
||
|
|
match new_pos {
|
||
|
|
Some(n) => {
|
||
|
|
self.pos = n;
|
||
|
|
Ok(self.pos)
|
||
|
|
}
|
||
|
|
None => Err(Error::new(
|
||
|
|
ErrorKind::InvalidInput,
|
||
|
|
"invalid seek to a negative or overflowing position",
|
||
|
|
)),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn stream_len(&mut self) -> io::Result<u64> {
|
||
|
|
Ok(self.inner.as_ref().len() as u64)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn stream_position(&mut self) -> io::Result<u64> {
|
||
|
|
Ok(self.pos)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl<T> Read for Cursor<T>
|
||
|
|
where
|
||
|
|
T: AsRef<[u8]>,
|
||
|
|
{
|
||
|
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||
|
|
let n = Read::read(&mut self.get_ref().as_ref(), buf)?;
|
||
|
|
self.pos += n as u64;
|
||
|
|
Ok(n)
|
||
|
|
}
|
||
|
|
|
||
|
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||
|
|
let n = buf.len();
|
||
|
|
Read::read_exact(&mut self.get_ref().as_ref(), buf)?;
|
||
|
|
self.pos += n as u64;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
#[inline]
|
||
|
|
unsafe fn initializer(&self) -> Initializer {
|
||
|
|
Initializer::nop()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "collections")]
|
||
|
|
impl<T> BufRead for Cursor<T>
|
||
|
|
where
|
||
|
|
T: AsRef<[u8]>,
|
||
|
|
{
|
||
|
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||
|
|
let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
|
||
|
|
Ok(&self.inner.as_ref()[(amt as usize)..])
|
||
|
|
}
|
||
|
|
fn consume(&mut self, amt: usize) {
|
||
|
|
self.pos += amt as u64;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Non-resizing write implementation
|
||
|
|
#[inline]
|
||
|
|
fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
|
||
|
|
let pos = cmp::min(*pos_mut, slice.len() as u64);
|
||
|
|
let amt = (&mut slice[(pos as usize)..]).write(buf)?;
|
||
|
|
*pos_mut += amt as u64;
|
||
|
|
Ok(amt)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Resizing write implementation
|
||
|
|
#[cfg(feature = "collections")]
|
||
|
|
fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
|
||
|
|
let pos: usize = (*pos_mut).try_into().map_err(|_| {
|
||
|
|
Error::new(
|
||
|
|
ErrorKind::InvalidInput,
|
||
|
|
"cursor position exceeds maximum possible vector length",
|
||
|
|
)
|
||
|
|
})?;
|
||
|
|
// Make sure the internal buffer is as least as big as where we
|
||
|
|
// currently are
|
||
|
|
let len = vec.len();
|
||
|
|
if len < pos {
|
||
|
|
// use `resize` so that the zero filling is as efficient as possible
|
||
|
|
vec.resize(pos, 0);
|
||
|
|
}
|
||
|
|
// Figure out what bytes will be used to overwrite what's currently
|
||
|
|
// there (left), and what will be appended on the end (right)
|
||
|
|
{
|
||
|
|
let space = vec.len() - pos;
|
||
|
|
let (left, right) = buf.split_at(cmp::min(space, buf.len()));
|
||
|
|
vec[pos..pos + left.len()].copy_from_slice(left);
|
||
|
|
vec.extend_from_slice(right);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Bump us forward
|
||
|
|
*pos_mut = (pos + buf.len()) as u64;
|
||
|
|
Ok(buf.len())
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Write for Cursor<&mut [u8]> {
|
||
|
|
#[inline]
|
||
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||
|
|
slice_write(&mut self.pos, self.inner, buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[inline]
|
||
|
|
fn flush(&mut self) -> io::Result<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "collections")]
|
||
|
|
impl Write for Cursor<&mut Vec<u8>> {
|
||
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||
|
|
vec_write(&mut self.pos, self.inner, buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[inline]
|
||
|
|
fn flush(&mut self) -> io::Result<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "collections")]
|
||
|
|
impl Write for Cursor<Vec<u8>> {
|
||
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||
|
|
vec_write(&mut self.pos, &mut self.inner, buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[inline]
|
||
|
|
fn flush(&mut self) -> io::Result<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(feature = "alloc")]
|
||
|
|
impl Write for Cursor<Box<[u8]>> {
|
||
|
|
#[inline]
|
||
|
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||
|
|
slice_write(&mut self.pos, &mut self.inner, buf)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[inline]
|
||
|
|
fn flush(&mut self) -> io::Result<()> {
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#[cfg(test)]
|
||
|
|
mod tests {
|
||
|
|
use crate::io::prelude::*;
|
||
|
|
use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_vec_writer() {
|
||
|
|
let mut writer = Vec::new();
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(
|
||
|
|
writer
|
||
|
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||
|
|
.unwrap(),
|
||
|
|
3
|
||
|
|
);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||
|
|
assert_eq!(writer, b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_mem_writer() {
|
||
|
|
let mut writer = Cursor::new(Vec::new());
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(
|
||
|
|
writer
|
||
|
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||
|
|
.unwrap(),
|
||
|
|
3
|
||
|
|
);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_mem_mut_writer() {
|
||
|
|
let mut vec = Vec::new();
|
||
|
|
let mut writer = Cursor::new(&mut vec);
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(
|
||
|
|
writer
|
||
|
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||
|
|
.unwrap(),
|
||
|
|
3
|
||
|
|
);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_box_slice_writer() {
|
||
|
|
let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
|
||
|
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||
|
|
assert_eq!(&**writer.get_ref(), b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_box_slice_writer_vectored() {
|
||
|
|
let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(
|
||
|
|
writer
|
||
|
|
.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
|
||
|
|
.unwrap(),
|
||
|
|
7,
|
||
|
|
);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||
|
|
assert_eq!(&**writer.get_ref(), b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_buf_writer() {
|
||
|
|
let mut buf = [0 as u8; 9];
|
||
|
|
{
|
||
|
|
let mut writer = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
|
||
|
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||
|
|
}
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_buf_writer_vectored() {
|
||
|
|
let mut buf = [0 as u8; 9];
|
||
|
|
{
|
||
|
|
let mut writer = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(
|
||
|
|
writer
|
||
|
|
.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
|
||
|
|
.unwrap(),
|
||
|
|
7,
|
||
|
|
);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
|
||
|
|
}
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_buf_writer_seek() {
|
||
|
|
let mut buf = [0 as u8; 8];
|
||
|
|
{
|
||
|
|
let mut writer = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
|
||
|
|
assert_eq!(writer.position(), 2);
|
||
|
|
assert_eq!(writer.write(&[2]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 3);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(writer.write(&[3]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 2);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||
|
|
assert_eq!(writer.position(), 7);
|
||
|
|
assert_eq!(writer.write(&[4]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
}
|
||
|
|
let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_buf_writer_error() {
|
||
|
|
let mut buf = [0 as u8; 2];
|
||
|
|
let mut writer = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_mem_reader() {
|
||
|
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
assert_eq!(reader.position(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||
|
|
assert_eq!(reader.position(), 1);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf = [0; 4];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||
|
|
assert_eq!(reader.position(), 5);
|
||
|
|
let b: &[_] = &[1, 2, 3, 4];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||
|
|
let b: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(&buf[..3], b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_mem_reader_vectored() {
|
||
|
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||
|
|
assert_eq!(reader.position(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||
|
|
.unwrap(),
|
||
|
|
1,
|
||
|
|
);
|
||
|
|
assert_eq!(reader.position(), 1);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf1 = [0; 4];
|
||
|
|
let mut buf2 = [0; 4];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
|
||
|
|
.unwrap(),
|
||
|
|
7,
|
||
|
|
);
|
||
|
|
let b1: &[_] = &[1, 2, 3, 4];
|
||
|
|
let b2: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(buf1, b1);
|
||
|
|
assert_eq!(&buf2[..3], b2);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_boxed_slice_reader() {
|
||
|
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
assert_eq!(reader.position(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||
|
|
assert_eq!(reader.position(), 1);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf = [0; 4];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||
|
|
assert_eq!(reader.position(), 5);
|
||
|
|
let b: &[_] = &[1, 2, 3, 4];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||
|
|
let b: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(&buf[..3], b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_boxed_slice_reader_vectored() {
|
||
|
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||
|
|
assert_eq!(reader.position(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||
|
|
.unwrap(),
|
||
|
|
1,
|
||
|
|
);
|
||
|
|
assert_eq!(reader.position(), 1);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf1 = [0; 4];
|
||
|
|
let mut buf2 = [0; 4];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
|
||
|
|
.unwrap(),
|
||
|
|
7,
|
||
|
|
);
|
||
|
|
let b1: &[_] = &[1, 2, 3, 4];
|
||
|
|
let b2: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(buf1, b1);
|
||
|
|
assert_eq!(&buf2[..3], b2);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn read_to_end() {
|
||
|
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||
|
|
let mut v = Vec::new();
|
||
|
|
reader.read_to_end(&mut v).unwrap();
|
||
|
|
assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_slice_reader() {
|
||
|
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
let reader = &mut &in_buf[..];
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||
|
|
assert_eq!(reader.len(), 7);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(&buf[..], b);
|
||
|
|
let mut buf = [0; 4];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||
|
|
assert_eq!(reader.len(), 3);
|
||
|
|
let b: &[_] = &[1, 2, 3, 4];
|
||
|
|
assert_eq!(&buf[..], b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||
|
|
let b: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(&buf[..3], b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_slice_reader_vectored() {
|
||
|
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
let reader = &mut &in_buf[..];
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||
|
|
.unwrap(),
|
||
|
|
1,
|
||
|
|
);
|
||
|
|
assert_eq!(reader.len(), 7);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf1 = [0; 4];
|
||
|
|
let mut buf2 = [0; 4];
|
||
|
|
assert_eq!(
|
||
|
|
reader
|
||
|
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
|
||
|
|
.unwrap(),
|
||
|
|
7,
|
||
|
|
);
|
||
|
|
let b1: &[_] = &[1, 2, 3, 4];
|
||
|
|
let b2: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(buf1, b1);
|
||
|
|
assert_eq!(&buf2[..3], b2);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_read_exact() {
|
||
|
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
let reader = &mut &in_buf[..];
|
||
|
|
let mut buf = [];
|
||
|
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||
|
|
let mut buf = [8];
|
||
|
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||
|
|
assert_eq!(buf[0], 0);
|
||
|
|
assert_eq!(reader.len(), 7);
|
||
|
|
let mut buf = [0, 0, 0, 0, 0, 0, 0];
|
||
|
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||
|
|
assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
|
||
|
|
assert_eq!(reader.len(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert!(reader.read_exact(&mut buf).is_err());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_buf_reader() {
|
||
|
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
let mut reader = Cursor::new(&in_buf[..]);
|
||
|
|
let mut buf = [];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
assert_eq!(reader.position(), 0);
|
||
|
|
let mut buf = [0];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||
|
|
assert_eq!(reader.position(), 1);
|
||
|
|
let b: &[_] = &[0];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
let mut buf = [0; 4];
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||
|
|
assert_eq!(reader.position(), 5);
|
||
|
|
let b: &[_] = &[1, 2, 3, 4];
|
||
|
|
assert_eq!(buf, b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||
|
|
let b: &[_] = &[5, 6, 7];
|
||
|
|
assert_eq!(&buf[..3], b);
|
||
|
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn seek_past_end() {
|
||
|
|
let buf = [0xff];
|
||
|
|
let mut r = Cursor::new(&buf[..]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||
|
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||
|
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||
|
|
|
||
|
|
let mut buf = [0];
|
||
|
|
let mut r = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||
|
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||
|
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn seek_past_i64() {
|
||
|
|
let buf = [0xff];
|
||
|
|
let mut r = Cursor::new(&buf[..]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||
|
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||
|
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||
|
|
|
||
|
|
let mut buf = [0];
|
||
|
|
let mut r = Cursor::new(&mut buf[..]);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||
|
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||
|
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn seek_before_0() {
|
||
|
|
let buf = [0xff];
|
||
|
|
let mut r = Cursor::new(&buf[..]);
|
||
|
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10]);
|
||
|
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||
|
|
|
||
|
|
let mut buf = [0];
|
||
|
|
let mut r = Cursor::new(&mut buf[..]);
|
||
|
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||
|
|
|
||
|
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||
|
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_seekable_mem_writer() {
|
||
|
|
let mut writer = Cursor::new(Vec::<u8>::new());
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||
|
|
assert_eq!(writer.position(), 1);
|
||
|
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||
|
|
assert_eq!(writer.position(), 8);
|
||
|
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
|
||
|
|
assert_eq!(writer.position(), 0);
|
||
|
|
assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
|
||
|
|
let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
|
||
|
|
assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
|
||
|
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||
|
|
assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
|
||
|
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
|
||
|
|
assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
|
||
|
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||
|
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
|
||
|
|
assert_eq!(&writer.get_ref()[..], b);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn vec_seek_past_end() {
|
||
|
|
let mut r = Cursor::new(Vec::new());
|
||
|
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||
|
|
assert_eq!(r.write(&[3]).unwrap(), 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn vec_seek_before_0() {
|
||
|
|
let mut r = Cursor::new(Vec::new());
|
||
|
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
#[cfg(target_pointer_width = "32")]
|
||
|
|
fn vec_seek_and_write_past_usize_max() {
|
||
|
|
let mut c = Cursor::new(Vec::new());
|
||
|
|
c.set_position(<usize>::max_value() as u64 + 1);
|
||
|
|
assert!(c.write_all(&[1, 2, 3]).is_err());
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_partial_eq() {
|
||
|
|
assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
|
||
|
|
}
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn test_eq() {
|
||
|
|
struct AssertEq<T: Eq>(pub T);
|
||
|
|
|
||
|
|
let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
|
||
|
|
}
|
||
|
|
}
|