aboutsummaryrefslogtreecommitdiff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/test_buf.rs33
-rw-r--r--tests/test_buf_mut.rs55
-rw-r--r--tests/test_bytes.rs17
-rw-r--r--tests/test_bytes_odd_alloc.rs2
-rw-r--r--tests/test_chain.rs11
-rw-r--r--tests/test_reader.rs6
-rw-r--r--tests/test_take.rs4
7 files changed, 78 insertions, 50 deletions
diff --git a/tests/test_buf.rs b/tests/test_buf.rs
index 17bdd54..fbad003 100644
--- a/tests/test_buf.rs
+++ b/tests/test_buf.rs
@@ -9,17 +9,17 @@ fn test_fresh_cursor_vec() {
let mut buf = &b"hello"[..];
assert_eq!(buf.remaining(), 5);
- assert_eq!(buf.bytes(), b"hello");
+ assert_eq!(buf.chunk(), b"hello");
buf.advance(2);
assert_eq!(buf.remaining(), 3);
- assert_eq!(buf.bytes(), b"llo");
+ assert_eq!(buf.chunk(), b"llo");
buf.advance(3);
assert_eq!(buf.remaining(), 0);
- assert_eq!(buf.bytes(), b"");
+ assert_eq!(buf.chunk(), b"");
}
#[test]
@@ -53,7 +53,7 @@ fn test_bufs_vec() {
let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
- assert_eq!(1, buf.bytes_vectored(&mut dst[..]));
+ assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
}
#[test]
@@ -63,9 +63,9 @@ fn test_vec_deque() {
let mut buffer: VecDeque<u8> = VecDeque::new();
buffer.extend(b"hello world");
assert_eq!(11, buffer.remaining());
- assert_eq!(b"hello world", buffer.bytes());
+ assert_eq!(b"hello world", buffer.chunk());
buffer.advance(6);
- assert_eq!(b"world", buffer.bytes());
+ assert_eq!(b"world", buffer.chunk());
buffer.extend(b" piece");
let mut out = [0; 11];
buffer.copy_to_slice(&mut out);
@@ -81,8 +81,8 @@ fn test_deref_buf_forwards() {
unreachable!("remaining");
}
- fn bytes(&self) -> &[u8] {
- unreachable!("bytes");
+ fn chunk(&self) -> &[u8] {
+ unreachable!("chunk");
}
fn advance(&mut self, _: usize) {
@@ -101,3 +101,20 @@ fn test_deref_buf_forwards() {
assert_eq!((Box::new(Special) as Box<dyn Buf>).get_u8(), b'x');
assert_eq!(Box::new(Special).get_u8(), b'x');
}
+
+#[test]
+fn copy_to_bytes_less() {
+ let mut buf = &b"hello world"[..];
+
+ let bytes = buf.copy_to_bytes(5);
+ assert_eq!(bytes, &b"hello"[..]);
+ assert_eq!(buf, &b" world"[..])
+}
+
+#[test]
+#[should_panic]
+fn copy_to_bytes_overflow() {
+ let mut buf = &b"hello world"[..];
+
+ let _bytes = buf.copy_to_bytes(12);
+}
diff --git a/tests/test_buf_mut.rs b/tests/test_buf_mut.rs
index b91e2e5..8d270e3 100644
--- a/tests/test_buf_mut.rs
+++ b/tests/test_buf_mut.rs
@@ -1,7 +1,6 @@
#![warn(rust_2018_idioms)]
-#[cfg(feature = "std")]
-use bytes::buf::IoSliceMut;
+use bytes::buf::UninitSlice;
use bytes::{BufMut, BytesMut};
use core::fmt::Write;
use core::usize;
@@ -12,7 +11,7 @@ fn test_vec_as_mut_buf() {
assert_eq!(buf.remaining_mut(), usize::MAX);
- assert!(buf.bytes_mut().len() >= 64);
+ assert!(buf.chunk_mut().len() >= 64);
buf.put(&b"zomg"[..]);
@@ -66,23 +65,6 @@ fn test_clone() {
assert!(buf != buf2);
}
-#[cfg(feature = "std")]
-#[test]
-fn test_bufs_vec_mut() {
- let b1: &mut [u8] = &mut [];
- let b2: &mut [u8] = &mut [];
- let mut dst = [IoSliceMut::from(b1), IoSliceMut::from(b2)];
-
- // with no capacity
- let mut buf = BytesMut::new();
- assert_eq!(buf.capacity(), 0);
- assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
-
- // with capacity
- let mut buf = BytesMut::with_capacity(64);
- assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
-}
-
#[test]
fn test_mut_slice() {
let mut v = vec![0, 0, 0, 0];
@@ -94,13 +76,13 @@ fn test_mut_slice() {
fn test_deref_bufmut_forwards() {
struct Special;
- impl BufMut for Special {
+ unsafe impl BufMut for Special {
fn remaining_mut(&self) -> usize {
unreachable!("remaining_mut");
}
- fn bytes_mut(&mut self) -> &mut [std::mem::MaybeUninit<u8>] {
- unreachable!("bytes_mut");
+ fn chunk_mut(&mut self) -> &mut UninitSlice {
+ unreachable!("chunk_mut");
}
unsafe fn advance_mut(&mut self, _: usize) {
@@ -118,3 +100,30 @@ fn test_deref_bufmut_forwards() {
(Box::new(Special) as Box<dyn BufMut>).put_u8(b'x');
Box::new(Special).put_u8(b'x');
}
+
+#[test]
+#[should_panic]
+fn write_byte_panics_if_out_of_bounds() {
+ let mut data = [b'b', b'a', b'r'];
+
+ let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
+ slice.write_byte(4, b'f');
+}
+
+#[test]
+#[should_panic]
+fn copy_from_slice_panics_if_different_length_1() {
+ let mut data = [b'b', b'a', b'r'];
+
+ let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
+ slice.copy_from_slice(b"a");
+}
+
+#[test]
+#[should_panic]
+fn copy_from_slice_panics_if_different_length_2() {
+ let mut data = [b'b', b'a', b'r'];
+
+ let slice = unsafe { UninitSlice::from_raw_parts_mut(data.as_mut_ptr(), 3) };
+ slice.copy_from_slice(b"abcd");
+}
diff --git a/tests/test_bytes.rs b/tests/test_bytes.rs
index 6b106a6..b9e6ce4 100644
--- a/tests/test_bytes.rs
+++ b/tests/test_bytes.rs
@@ -461,6 +461,7 @@ fn reserve_allocates_at_least_original_capacity() {
}
#[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
fn reserve_max_original_capacity_value() {
const SIZE: usize = 128 * 1024;
@@ -608,15 +609,15 @@ fn advance_past_len() {
#[test]
// Only run these tests on little endian systems. CI uses qemu for testing
-// little endian... and qemu doesn't really support threading all that well.
-#[cfg(target_endian = "little")]
+// big endian... and qemu doesn't really support threading all that well.
+#[cfg(any(miri, target_endian = "little"))]
fn stress() {
// Tests promoting a buffer from a vec -> shared in a concurrent situation
use std::sync::{Arc, Barrier};
use std::thread;
const THREADS: usize = 8;
- const ITERS: usize = 1_000;
+ const ITERS: usize = if cfg!(miri) { 100 } else { 1_000 };
for i in 0..ITERS {
let data = [i as u8; 256];
@@ -912,20 +913,20 @@ fn bytes_buf_mut_advance() {
let mut bytes = BytesMut::with_capacity(1024);
unsafe {
- let ptr = bytes.bytes_mut().as_ptr();
- assert_eq!(1024, bytes.bytes_mut().len());
+ let ptr = bytes.chunk_mut().as_mut_ptr();
+ assert_eq!(1024, bytes.chunk_mut().len());
bytes.advance_mut(10);
- let next = bytes.bytes_mut().as_ptr();
- assert_eq!(1024 - 10, bytes.bytes_mut().len());
+ let next = bytes.chunk_mut().as_mut_ptr();
+ assert_eq!(1024 - 10, bytes.chunk_mut().len());
assert_eq!(ptr.offset(10), next);
// advance to the end
bytes.advance_mut(1024 - 10);
// The buffer size is doubled
- assert_eq!(1024, bytes.bytes_mut().len());
+ assert_eq!(1024, bytes.chunk_mut().len());
}
}
diff --git a/tests/test_bytes_odd_alloc.rs b/tests/test_bytes_odd_alloc.rs
index 4ce424b..04ba7c2 100644
--- a/tests/test_bytes_odd_alloc.rs
+++ b/tests/test_bytes_odd_alloc.rs
@@ -1,6 +1,8 @@
//! Test using `Bytes` with an allocator that hands out "odd" pointers for
//! vectors (pointers where the LSB is set).
+#![cfg(not(miri))] // Miri does not support custom allocators (also, Miri is "odd" by default with 50% chance)
+
use std::alloc::{GlobalAlloc, Layout, System};
use std::ptr;
diff --git a/tests/test_chain.rs b/tests/test_chain.rs
index 6dbc45d..500ccd4 100644
--- a/tests/test_chain.rs
+++ b/tests/test_chain.rs
@@ -1,6 +1,5 @@
#![warn(rust_2018_idioms)]
-use bytes::buf::{BufExt, BufMutExt};
use bytes::{Buf, BufMut, Bytes};
#[cfg(feature = "std")]
use std::io::IoSlice;
@@ -10,7 +9,7 @@ fn collect_two_bufs() {
let a = Bytes::from(&b"hello"[..]);
let b = Bytes::from(&b"world"[..]);
- let res = a.chain(b).to_bytes();
+ let res = a.chain(b).copy_to_bytes(10);
assert_eq!(res, &b"helloworld"[..]);
}
@@ -63,7 +62,7 @@ fn vectored_read() {
IoSlice::new(b4),
];
- assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+ assert_eq!(2, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"hello"[..]);
assert_eq!(iovecs[1][..], b"world"[..]);
assert_eq!(iovecs[2][..], b""[..]);
@@ -84,7 +83,7 @@ fn vectored_read() {
IoSlice::new(b4),
];
- assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+ assert_eq!(2, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"llo"[..]);
assert_eq!(iovecs[1][..], b"world"[..]);
assert_eq!(iovecs[2][..], b""[..]);
@@ -105,7 +104,7 @@ fn vectored_read() {
IoSlice::new(b4),
];
- assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+ assert_eq!(1, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"world"[..]);
assert_eq!(iovecs[1][..], b""[..]);
assert_eq!(iovecs[2][..], b""[..]);
@@ -126,7 +125,7 @@ fn vectored_read() {
IoSlice::new(b4),
];
- assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+ assert_eq!(1, buf.chunks_vectored(&mut iovecs));
assert_eq!(iovecs[0][..], b"ld"[..]);
assert_eq!(iovecs[1][..], b""[..]);
assert_eq!(iovecs[2][..], b""[..]);
diff --git a/tests/test_reader.rs b/tests/test_reader.rs
index 10b480f..897aff6 100644
--- a/tests/test_reader.rs
+++ b/tests/test_reader.rs
@@ -3,13 +3,13 @@
use std::io::{BufRead, Read};
-use bytes::buf::BufExt;
+use bytes::Buf;
#[test]
fn read() {
let buf1 = &b"hello "[..];
let buf2 = &b"world"[..];
- let buf = BufExt::chain(buf1, buf2); // Disambiguate with Read::chain
+ let buf = Buf::chain(buf1, buf2); // Disambiguate with Read::chain
let mut buffer = Vec::new();
buf.reader().read_to_end(&mut buffer).unwrap();
assert_eq!(b"hello world", &buffer[..]);
@@ -19,7 +19,7 @@ fn read() {
fn buf_read() {
let buf1 = &b"hell"[..];
let buf2 = &b"o\nworld"[..];
- let mut reader = BufExt::chain(buf1, buf2).reader();
+ let mut reader = Buf::chain(buf1, buf2).reader();
let mut line = String::new();
reader.read_line(&mut line).unwrap();
assert_eq!("hello\n", &line);
diff --git a/tests/test_take.rs b/tests/test_take.rs
index 0afb28b..a23a29e 100644
--- a/tests/test_take.rs
+++ b/tests/test_take.rs
@@ -1,6 +1,6 @@
#![warn(rust_2018_idioms)]
-use bytes::buf::{Buf, BufExt};
+use bytes::buf::Buf;
#[test]
fn long_take() {
@@ -8,5 +8,5 @@ fn long_take() {
// overrun the buffer. Regression test for #138.
let buf = b"hello world".take(100);
assert_eq!(11, buf.remaining());
- assert_eq!(b"hello world", buf.bytes());
+ assert_eq!(b"hello world", buf.chunk());
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-01 21:17:03 +0000