mirror of
https://github.com/ntex-rs/ntex.git
synced 2025-04-03 21:07:39 +03:00
Use const generics for helper traits (From, PartialEq, PartialOrd) (#284)
This commit is contained in:
Nikolay Kim
GitHub
parent
f40608633e
commit
d99178519e
5 changed files with 216 additions and 45 deletions
|
|
@ -1,5 +1,9 @@
|
|||
# Changes
|
||||
|
||||
## [0.1.22] (2024-01-16)
|
||||
|
||||
* Use const generics for helper traits (From, PartialEq, PartialOrd)
|
||||
|
||||
## [0.1.21] (2023-11-1)
|
||||
|
||||
* Data race in BytesMut #243
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
[package]
|
||||
name = "ntex-bytes"
|
||||
version = "0.1.21"
|
||||
version = "0.1.22"
|
||||
authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Carl Lerche <me@carllerche.com>"]
|
||||
description = "Types and traits for working with bytes (bytes crate fork)"
|
||||
documentation = "https://docs.rs/ntex-bytes"
|
||||
|
|
@ -27,4 +27,4 @@ simdutf8 = { version = "0.1.4", optional = true }
|
|||
[dev-dependencies]
|
||||
serde_test = "1.0"
|
||||
serde_json = "1.0"
|
||||
ntex = { version = "1.0.0", features = ["tokio"] }
|
||||
ntex = { version = "1.0", features = ["tokio"] }
|
||||
|
|
|
|||
|
|
@ -24,12 +24,12 @@ use crate::{buf::IntoIter, buf::UninitSlice, debug, Buf, BufMut};
|
|||
/// let mut mem = Bytes::from(&b"Hello world"[..]);
|
||||
/// let a = mem.slice(0..5);
|
||||
///
|
||||
/// assert_eq!(&a[..], b"Hello");
|
||||
/// assert_eq!(a, b"Hello");
|
||||
///
|
||||
/// let b = mem.split_to(6);
|
||||
///
|
||||
/// assert_eq!(&mem[..], b"world");
|
||||
/// assert_eq!(&b[..], b"Hello ");
|
||||
/// assert_eq!(mem, b"world");
|
||||
/// assert_eq!(b, b"Hello ");
|
||||
/// ```
|
||||
///
|
||||
/// # Memory layout
|
||||
|
|
@ -135,7 +135,7 @@ pub struct Bytes {
|
|||
/// buf.put_u8(b'e');
|
||||
/// buf.put("llo");
|
||||
///
|
||||
/// assert_eq!(&buf[..], b"hello");
|
||||
/// assert_eq!(buf, b"hello");
|
||||
///
|
||||
/// // Freeze the buffer so that it can be shared
|
||||
/// let a = buf.freeze();
|
||||
|
|
@ -143,8 +143,8 @@ pub struct Bytes {
|
|||
/// // This does not allocate, instead `b` points to the same memory.
|
||||
/// let b = a.clone();
|
||||
///
|
||||
/// assert_eq!(&a[..], b"hello");
|
||||
/// assert_eq!(&b[..], b"hello");
|
||||
/// assert_eq!(a, b"hello");
|
||||
/// assert_eq!(b, b"hello");
|
||||
/// ```
|
||||
pub struct BytesMut {
|
||||
inner: Inner,
|
||||
|
|
@ -189,8 +189,8 @@ pub struct BytesMut {
|
|||
/// // This does not allocate, instead `b` points to the same memory.
|
||||
/// let b = a.clone();
|
||||
///
|
||||
/// assert_eq!(&a[..], b"hello");
|
||||
/// assert_eq!(&b[..], b"hello");
|
||||
/// assert_eq!(a, b"hello");
|
||||
/// assert_eq!(b, b"hello");
|
||||
/// ```
|
||||
pub struct BytesVec {
|
||||
inner: InnerVec,
|
||||
|
|
@ -536,7 +536,7 @@ impl Bytes {
|
|||
/// ```
|
||||
/// use ntex_bytes::Bytes;
|
||||
///
|
||||
/// let a = Bytes::from(&b"hello world"[..]);
|
||||
/// let a = Bytes::from(b"hello world");
|
||||
/// let b = a.slice(2..5);
|
||||
///
|
||||
/// assert_eq!(&b[..], b"llo");
|
||||
|
|
@ -601,7 +601,7 @@ impl Bytes {
|
|||
/// let as_slice = bytes.as_ref();
|
||||
/// let subset = &as_slice[2..6];
|
||||
/// let subslice = bytes.slice_ref(&subset);
|
||||
/// assert_eq!(&subslice[..], b"2345");
|
||||
/// assert_eq!(subslice, b"2345");
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
|
|
@ -639,8 +639,8 @@ impl Bytes {
|
|||
/// let mut a = Bytes::from(&b"hello world"[..]);
|
||||
/// let b = a.split_off(5);
|
||||
///
|
||||
/// assert_eq!(&a[..], b"hello");
|
||||
/// assert_eq!(&b[..], b" world");
|
||||
/// assert_eq!(a, b"hello");
|
||||
/// assert_eq!(b, b" world");
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
|
|
@ -678,8 +678,8 @@ impl Bytes {
|
|||
/// let mut a = Bytes::from(&b"hello world"[..]);
|
||||
/// let b = a.split_to(5);
|
||||
///
|
||||
/// assert_eq!(&a[..], b" world");
|
||||
/// assert_eq!(&b[..], b"hello");
|
||||
/// assert_eq!(a, b" world");
|
||||
/// assert_eq!(b, b"hello");
|
||||
/// ```
|
||||
///
|
||||
/// # Panics
|
||||
|
|
@ -957,6 +957,12 @@ impl From<&'static str> for Bytes {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> From<&'a [u8; N]> for Bytes {
|
||||
fn from(src: &'a [u8; N]) -> Bytes {
|
||||
Bytes::copy_from_slice(src)
|
||||
}
|
||||
}
|
||||
|
||||
impl FromIterator<u8> for Bytes {
|
||||
fn from_iter<T: IntoIterator<Item = u8>>(into_iter: T) -> Self {
|
||||
BytesMut::from_iter(into_iter).freeze()
|
||||
|
|
@ -1218,17 +1224,17 @@ impl BytesMut {
|
|||
/// let b2 = b1.clone();
|
||||
///
|
||||
/// let th = thread::spawn(move || {
|
||||
/// assert_eq!(&b1[..], b"hello world");
|
||||
/// assert_eq!(b1, b"hello world");
|
||||
/// });
|
||||
///
|
||||
/// assert_eq!(&b2[..], b"hello world");
|
||||
/// assert_eq!(b2, b"hello world");
|
||||
/// th.join().unwrap();
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn freeze(self) -> Bytes {
|
||||
if self.inner.len() <= INLINE_CAP {
|
||||
Bytes {
|
||||
inner: self.inner.to_inline(),
|
||||
inner: Inner::from_slice_inline(self.inner.as_ref()),
|
||||
}
|
||||
} else {
|
||||
Bytes { inner: self.inner }
|
||||
|
|
@ -1733,9 +1739,7 @@ impl From<String> for BytesMut {
|
|||
|
||||
impl<'a> From<&'a [u8]> for BytesMut {
|
||||
fn from(src: &'a [u8]) -> BytesMut {
|
||||
let len = src.len();
|
||||
|
||||
if len == 0 {
|
||||
if src.is_empty() {
|
||||
BytesMut::new()
|
||||
} else {
|
||||
BytesMut::copy_from_slice_in(src, PoolId::DEFAULT.pool_ref())
|
||||
|
|
@ -1743,6 +1747,18 @@ impl<'a> From<&'a [u8]> for BytesMut {
|
|||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> From<[u8; N]> for BytesMut {
|
||||
fn from(src: [u8; N]) -> BytesMut {
|
||||
BytesMut::copy_from_slice_in(src, PoolId::DEFAULT.pool_ref())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> From<&'a [u8; N]> for BytesMut {
|
||||
fn from(src: &'a [u8; N]) -> BytesMut {
|
||||
BytesMut::copy_from_slice_in(src, PoolId::DEFAULT.pool_ref())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> From<&'a str> for BytesMut {
|
||||
#[inline]
|
||||
fn from(src: &'a str) -> BytesMut {
|
||||
|
|
@ -2052,10 +2068,10 @@ impl BytesVec {
|
|||
/// let b2 = b1.clone();
|
||||
///
|
||||
/// let th = thread::spawn(move || {
|
||||
/// assert_eq!(&b1[..], b"hello world");
|
||||
/// assert_eq!(b1, b"hello world");
|
||||
/// });
|
||||
///
|
||||
/// assert_eq!(&b2[..], b"hello world");
|
||||
/// assert_eq!(b2, b"hello world");
|
||||
/// th.join().unwrap();
|
||||
/// ```
|
||||
#[inline]
|
||||
|
|
@ -3149,22 +3165,6 @@ impl Inner {
|
|||
(self as *const Inner as *const u8).offset(INLINE_DATA_OFFSET)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn to_inline(&self) -> Inner {
|
||||
unsafe {
|
||||
let mut inner = Inner {
|
||||
arc: NonNull::new_unchecked(KIND_INLINE as *mut Shared),
|
||||
ptr: ptr::null_mut(),
|
||||
cap: 0,
|
||||
len: 0,
|
||||
};
|
||||
let len = self.len();
|
||||
inner.as_raw()[..len].copy_from_slice(self.as_ref());
|
||||
inner.set_inline_len(len);
|
||||
inner
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn inline_len(&self) -> usize {
|
||||
// This is undefind behavior due to a data race, but experimental
|
||||
|
|
@ -3708,12 +3708,30 @@ impl PartialEq<[u8]> for BytesMut {
|
|||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<[u8; N]> for BytesMut {
|
||||
fn eq(&self, other: &[u8; N]) -> bool {
|
||||
&**self == other
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<BytesMut> for [u8] {
|
||||
fn eq(&self, other: &BytesMut) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<BytesMut> for [u8; N] {
|
||||
fn eq(&self, other: &BytesMut) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> PartialEq<BytesMut> for &'a [u8; N] {
|
||||
fn eq(&self, other: &BytesMut) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<str> for BytesMut {
|
||||
fn eq(&self, other: &str) -> bool {
|
||||
&**self == other.as_bytes()
|
||||
|
|
@ -3777,24 +3795,54 @@ impl PartialEq<[u8]> for Bytes {
|
|||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<[u8; N]> for Bytes {
|
||||
fn eq(&self, other: &[u8; N]) -> bool {
|
||||
self.inner.as_ref() == other.as_ref()
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialOrd<[u8]> for Bytes {
|
||||
fn partial_cmp(&self, other: &[u8]) -> Option<cmp::Ordering> {
|
||||
self.inner.as_ref().partial_cmp(other)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialOrd<[u8; N]> for Bytes {
|
||||
fn partial_cmp(&self, other: &[u8; N]) -> Option<cmp::Ordering> {
|
||||
self.inner.as_ref().partial_cmp(other.as_ref())
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<Bytes> for [u8] {
|
||||
fn eq(&self, other: &Bytes) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<Bytes> for [u8; N] {
|
||||
fn eq(&self, other: &Bytes) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> PartialEq<Bytes> for &'a [u8; N] {
|
||||
fn eq(&self, other: &Bytes) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialOrd<Bytes> for [u8] {
|
||||
fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
|
||||
other.partial_cmp(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialOrd<Bytes> for [u8; N] {
|
||||
fn partial_cmp(&self, other: &Bytes) -> Option<cmp::Ordering> {
|
||||
other.partial_cmp(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<str> for Bytes {
|
||||
fn eq(&self, other: &str) -> bool {
|
||||
self.inner.as_ref() == other.as_bytes()
|
||||
|
|
@ -3957,12 +4005,30 @@ impl PartialEq<[u8]> for BytesVec {
|
|||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<[u8; N]> for BytesVec {
|
||||
fn eq(&self, other: &[u8; N]) -> bool {
|
||||
&**self == other
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<BytesVec> for [u8] {
|
||||
fn eq(&self, other: &BytesVec) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<const N: usize> PartialEq<BytesVec> for [u8; N] {
|
||||
fn eq(&self, other: &BytesVec) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, const N: usize> PartialEq<BytesVec> for &'a [u8; N] {
|
||||
fn eq(&self, other: &BytesVec) -> bool {
|
||||
*other == *self
|
||||
}
|
||||
}
|
||||
|
||||
impl PartialEq<str> for BytesVec {
|
||||
fn eq(&self, other: &str) -> bool {
|
||||
&**self == other.as_bytes()
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
#![deny(warnings, rust_2018_idioms)]
|
||||
|
||||
use ntex_bytes::Buf;
|
||||
use ntex_bytes::{Buf, Bytes, BytesMut};
|
||||
|
||||
#[test]
|
||||
fn test_fresh_cursor_vec() {
|
||||
|
|
@ -20,6 +20,43 @@ fn test_fresh_cursor_vec() {
|
|||
assert_eq!(buf.chunk(), b"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes() {
|
||||
let mut buf = Bytes::from(b"hello");
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 5);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"hello");
|
||||
|
||||
bytes::buf::Buf::advance(&mut buf, 2);
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 3);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"llo");
|
||||
|
||||
bytes::buf::Buf::advance(&mut buf, 3);
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 0);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_bytes_mut() {
|
||||
let mut buf = BytesMut::from(b"hello");
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 5);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"hello");
|
||||
|
||||
assert_eq!(bytes::buf::BufMut::remaining_mut(&mut buf), 27);
|
||||
bytes::buf::Buf::advance(&mut buf, 2);
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 3);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"llo");
|
||||
|
||||
bytes::buf::Buf::advance(&mut buf, 3);
|
||||
|
||||
assert_eq!(bytes::buf::Buf::remaining(&buf), 0);
|
||||
assert_eq!(bytes::buf::Buf::chunk(&buf), b"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_get_u8() {
|
||||
let mut buf = &b"\x21zomg"[..];
|
||||
|
|
|
|||
|
|
@ -207,9 +207,15 @@ fn index() {
|
|||
fn slice() {
|
||||
let a = Bytes::from(&b"hello world"[..]);
|
||||
|
||||
let b = a.slice(..);
|
||||
assert_eq!(b, b"hello world");
|
||||
|
||||
let b = a.slice(3..5);
|
||||
assert_eq!(b, b"lo"[..]);
|
||||
|
||||
let b = a.slice(3..=5);
|
||||
assert_eq!(b, b"lo "[..]);
|
||||
|
||||
let b = a.slice(0..0);
|
||||
assert_eq!(b, b""[..]);
|
||||
|
||||
|
|
@ -460,29 +466,56 @@ fn split_off_to_at_gt_len() {
|
|||
clippy::needless_borrow
|
||||
)]
|
||||
fn fns_defined_for_bytes() {
|
||||
let mut bytes = Bytes::from(&b"hello world"[..]);
|
||||
let bytes = Bytes::from(&b"hello world"[..]);
|
||||
let _ = bytes.as_ptr();
|
||||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
|
||||
let bytes = Bytes::from(b"hello world");
|
||||
assert_eq!(bytes, "hello world");
|
||||
assert_eq!(bytes, b"hello world");
|
||||
|
||||
assert!(bytes > "g");
|
||||
assert!(bytes > b"g");
|
||||
assert!(bytes > [b'g']);
|
||||
assert!(bytes > &[b'g'][..]);
|
||||
assert!(bytes > "g".to_string());
|
||||
assert!(bytes > "g".as_bytes().to_vec());
|
||||
assert!(bytes > Bytes::from("g"));
|
||||
assert!("g" > bytes);
|
||||
assert!("g".to_string() > bytes);
|
||||
assert!("g".as_bytes().to_vec() > bytes);
|
||||
assert!([b'g'] > bytes);
|
||||
assert!(Bytes::from(&"g"[..]) < bytes);
|
||||
|
||||
assert_eq!(bytes, "hello world");
|
||||
assert_eq!(bytes, "hello world".as_bytes().to_vec());
|
||||
assert_eq!(bytes, "hello world".to_string());
|
||||
assert_eq!(bytes, b"hello world");
|
||||
assert_eq!(bytes, &"hello world"[..]);
|
||||
assert_eq!(bytes, BytesVec::copy_from_slice(b"hello world"));
|
||||
assert_eq!(bytes, BytesMut::copy_from_slice(b"hello world"));
|
||||
assert_eq!(&bytes[..], b"hello world");
|
||||
assert_eq!(bytes.as_ref(), b"hello world");
|
||||
assert_eq!("hello world", bytes);
|
||||
assert_eq!("hello world".as_bytes().to_vec(), bytes);
|
||||
assert_eq!("hello world".to_string(), bytes);
|
||||
assert_eq!(b"hello world", bytes);
|
||||
assert_eq!(&"hello world"[..], bytes);
|
||||
assert_eq!(
|
||||
bytes,
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd']
|
||||
);
|
||||
assert_eq!(
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd'],
|
||||
bytes,
|
||||
);
|
||||
|
||||
let mut bytes = BytesMut::with_capacity(64);
|
||||
bytes.put(LONG);
|
||||
let bytes = bytes.freeze();
|
||||
assert_eq!(bytes.as_ref(), LONG);
|
||||
|
||||
let mut bytes = Bytes::from(&b"hello world"[..]);
|
||||
|
||||
// Iterator
|
||||
let v: Vec<u8> = (&bytes).iter().cloned().collect();
|
||||
|
|
@ -521,16 +554,35 @@ fn fns_defined_for_bytes_mut() {
|
|||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
assert_eq!(BorrowMut::<[u8]>::borrow_mut(&mut bytes), b"hello world");
|
||||
|
||||
let mut bytes = BytesMut::from(b"hello world");
|
||||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
assert_eq!(BorrowMut::<[u8]>::borrow_mut(&mut bytes), b"hello world");
|
||||
|
||||
let bytes = BytesMut::from([
|
||||
b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd',
|
||||
]);
|
||||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
|
||||
assert_eq!(bytes, "hello world");
|
||||
assert_eq!(bytes, "hello world".as_bytes().to_vec());
|
||||
assert_eq!(bytes, "hello world".to_string());
|
||||
assert_eq!(bytes, b"hello world");
|
||||
assert_eq!(bytes, &"hello world"[..]);
|
||||
assert_eq!(bytes, Bytes::copy_from_slice(b"hello world"));
|
||||
assert_eq!(bytes, BytesVec::copy_from_slice(b"hello world"));
|
||||
assert_eq!(
|
||||
bytes,
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd']
|
||||
);
|
||||
assert_eq!("hello world", bytes);
|
||||
assert_eq!("hello world".as_bytes().to_vec(), bytes);
|
||||
assert_eq!("hello world".to_string(), bytes);
|
||||
assert_eq!(b"hello world", bytes);
|
||||
assert_eq!(&"hello world"[..], bytes);
|
||||
assert_eq!(
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd'],
|
||||
bytes
|
||||
);
|
||||
|
||||
// Iterator
|
||||
let v: Vec<u8> = (&bytes).iter().cloned().collect();
|
||||
|
|
@ -584,16 +636,30 @@ fn fns_defined_for_bytes_vec() {
|
|||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
assert_eq!(BorrowMut::<[u8]>::borrow_mut(&mut bytes), b"hello world");
|
||||
|
||||
let mut bytes = BytesVec::copy_from_slice(b"hello world");
|
||||
assert_eq!(Borrow::<[u8]>::borrow(&bytes), b"hello world");
|
||||
assert_eq!(BorrowMut::<[u8]>::borrow_mut(&mut bytes), b"hello world");
|
||||
|
||||
assert_eq!(bytes, "hello world");
|
||||
assert_eq!(bytes, "hello world".as_bytes().to_vec());
|
||||
assert_eq!(bytes, "hello world".to_string());
|
||||
assert_eq!(bytes, b"hello world");
|
||||
assert_eq!(bytes, &"hello world"[..]);
|
||||
assert_eq!(bytes, Bytes::copy_from_slice(b"hello world"));
|
||||
assert_eq!(bytes, BytesMut::copy_from_slice(b"hello world"));
|
||||
assert_eq!(&bytes[..], b"hello world");
|
||||
assert_eq!(
|
||||
bytes,
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd']
|
||||
);
|
||||
assert_eq!("hello world", bytes);
|
||||
assert_eq!("hello world".as_bytes().to_vec(), bytes);
|
||||
assert_eq!("hello world".to_string(), bytes);
|
||||
assert_eq!("hello world", bytes);
|
||||
assert_eq!(b"hello world", bytes);
|
||||
assert_eq!(
|
||||
[b'h', b'e', b'l', b'l', b'o', b' ', b'w', b'o', b'r', b'l', b'd'],
|
||||
bytes
|
||||
);
|
||||
|
||||
// Iterator
|
||||
let v: Vec<u8> = bytes.iter().cloned().collect();
|
||||
|
|
@ -815,7 +881,6 @@ fn advance_vec() {
|
|||
assert_eq!(a, b"d zomg wat wat"[..]);
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn advance_past_len() {
|
||||
|
|
@ -823,7 +888,6 @@ fn advance_past_len() {
|
|||
a.advance(20);
|
||||
}
|
||||
|
||||
#[cfg(not(target_os = "macos"))]
|
||||
#[test]
|
||||
#[should_panic]
|
||||
fn advance_past_len_vec() {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue