diff options
Diffstat (limited to 'vendor/bytemuck/tests')
| -rw-r--r-- | vendor/bytemuck/tests/array_tests.rs | 12 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/cast_slice_tests.rs | 197 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/checked_tests.rs | 419 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/derive.rs | 77 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/doc_tests.rs | 123 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/offset_of_tests.rs | 60 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/std_tests.rs | 46 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/transparent.rs | 116 | ||||
| -rw-r--r-- | vendor/bytemuck/tests/wrapper_forgets.rs | 13 |
9 files changed, 0 insertions, 1063 deletions
diff --git a/vendor/bytemuck/tests/array_tests.rs b/vendor/bytemuck/tests/array_tests.rs deleted file mode 100644 index 4b9782b..0000000 --- a/vendor/bytemuck/tests/array_tests.rs +++ /dev/null @@ -1,12 +0,0 @@ -#[test] -pub fn test_cast_array() { - let x = [0u32, 1u32, 2u32]; - let _: [u16; 6] = bytemuck::cast(x); -} - -#[cfg(feature = "min_const_generics")] -#[test] -pub fn test_cast_long_array() { - let x = [0u32; 65]; - let _: [u16; 130] = bytemuck::cast(x); -} diff --git a/vendor/bytemuck/tests/cast_slice_tests.rs b/vendor/bytemuck/tests/cast_slice_tests.rs deleted file mode 100644 index ce6dedc..0000000 --- a/vendor/bytemuck/tests/cast_slice_tests.rs +++ /dev/null @@ -1,197 +0,0 @@ -#![allow(clippy::unnecessary_cast)] -#![allow(clippy::manual_slice_size_calculation)] - -use core::mem::size_of; - -use bytemuck::*; - -#[test] -fn test_try_cast_slice() { - // some align4 data - let u32_slice: &[u32] = &[4, 5, 6]; - // the same data as align1 - let the_bytes: &[u8] = try_cast_slice(u32_slice).unwrap(); - - assert_eq!( - u32_slice.as_ptr() as *const u32 as usize, - the_bytes.as_ptr() as *const u8 as usize - ); - assert_eq!( - u32_slice.len() * size_of::<u32>(), - the_bytes.len() * size_of::<u8>() - ); - - // by taking one byte off the front, we're definitely mis-aligned for u32. - let mis_aligned_bytes = &the_bytes[1..]; - assert_eq!( - try_cast_slice::<u8, u32>(mis_aligned_bytes), - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - ); - - // by taking one byte off the end, we're aligned but would have slop bytes for - // u32 - let the_bytes_len_minus1 = the_bytes.len() - 1; - let slop_bytes = &the_bytes[..the_bytes_len_minus1]; - assert_eq!( - try_cast_slice::<u8, u32>(slop_bytes), - Err(PodCastError::OutputSliceWouldHaveSlop) - ); - - // if we don't mess with it we can up-alignment cast - try_cast_slice::<u8, u32>(the_bytes).unwrap(); -} - -#[test] -fn test_try_cast_slice_mut() { - // some align4 data - let u32_slice: &mut [u32] = &mut [4, 5, 6]; - let u32_len = u32_slice.len(); - let u32_ptr = u32_slice.as_ptr(); - - // the same data as align1 - let the_bytes: &mut [u8] = try_cast_slice_mut(u32_slice).unwrap(); - let the_bytes_len = the_bytes.len(); - let the_bytes_ptr = the_bytes.as_ptr(); - - assert_eq!( - u32_ptr as *const u32 as usize, - the_bytes_ptr as *const u8 as usize - ); - assert_eq!(u32_len * size_of::<u32>(), the_bytes_len * size_of::<u8>()); - - // by taking one byte off the front, we're definitely mis-aligned for u32. - let mis_aligned_bytes = &mut the_bytes[1..]; - assert_eq!( - try_cast_slice_mut::<u8, u32>(mis_aligned_bytes), - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - ); - - // by taking one byte off the end, we're aligned but would have slop bytes for - // u32 - let the_bytes_len_minus1 = the_bytes.len() - 1; - let slop_bytes = &mut the_bytes[..the_bytes_len_minus1]; - assert_eq!( - try_cast_slice_mut::<u8, u32>(slop_bytes), - Err(PodCastError::OutputSliceWouldHaveSlop) - ); - - // if we don't mess with it we can up-alignment cast - try_cast_slice_mut::<u8, u32>(the_bytes).unwrap(); -} - -#[test] -fn test_types() { - let _: i32 = cast(1.0_f32); - let _: &mut i32 = cast_mut(&mut 1.0_f32); - let _: &i32 = cast_ref(&1.0_f32); - let _: &[i32] = cast_slice(&[1.0_f32]); - let _: &mut [i32] = cast_slice_mut(&mut [1.0_f32]); - // - let _: Result<i32, PodCastError> = try_cast(1.0_f32); - let _: Result<&mut i32, PodCastError> = try_cast_mut(&mut 1.0_f32); - let _: Result<&i32, PodCastError> = try_cast_ref(&1.0_f32); - let _: Result<&[i32], PodCastError> = try_cast_slice(&[1.0_f32]); - let _: Result<&mut [i32], PodCastError> = try_cast_slice_mut(&mut [1.0_f32]); -} - -#[test] -fn test_bytes_of() { - assert_eq!(bytes_of(&0xaabbccdd_u32), &0xaabbccdd_u32.to_ne_bytes()); - assert_eq!( - bytes_of_mut(&mut 0xaabbccdd_u32), - &mut 0xaabbccdd_u32.to_ne_bytes() - ); - let mut a = 0xaabbccdd_u32; - let a_addr = &a as *const _ as usize; - // ensure addresses match. - assert_eq!(bytes_of(&a).as_ptr() as usize, a_addr); - assert_eq!(bytes_of_mut(&mut a).as_ptr() as usize, a_addr); -} - -#[test] -fn test_try_from_bytes() { - let u32s = [0xaabbccdd, 0x11223344_u32]; - let bytes = bytemuck::cast_slice::<u32, u8>(&u32s); - assert_eq!(try_from_bytes::<u32>(&bytes[..4]), Ok(&u32s[0])); - assert_eq!( - try_from_bytes::<u32>(&bytes[..5]), - Err(PodCastError::SizeMismatch) - ); - assert_eq!( - try_from_bytes::<u32>(&bytes[..3]), - Err(PodCastError::SizeMismatch) - ); - assert_eq!( - try_from_bytes::<u32>(&bytes[1..5]), - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - ); -} - -#[test] -fn test_try_from_bytes_mut() { - let mut abcd = 0xaabbccdd; - let mut u32s = [abcd, 0x11223344_u32]; - let bytes = bytemuck::cast_slice_mut::<u32, u8>(&mut u32s); - assert_eq!(try_from_bytes_mut::<u32>(&mut bytes[..4]), Ok(&mut abcd)); - assert_eq!(try_from_bytes_mut::<u32>(&mut bytes[..4]), Ok(&mut abcd)); - assert_eq!( - try_from_bytes_mut::<u32>(&mut bytes[..5]), - Err(PodCastError::SizeMismatch) - ); - assert_eq!( - try_from_bytes_mut::<u32>(&mut bytes[..3]), - Err(PodCastError::SizeMismatch) - ); - assert_eq!( - try_from_bytes::<u32>(&bytes[1..5]), - Err(PodCastError::TargetAlignmentGreaterAndInputNotAligned) - ); -} - -#[test] -fn test_from_bytes() { - let abcd = 0xaabbccdd_u32; - let aligned_bytes = bytemuck::bytes_of(&abcd); - assert_eq!(from_bytes::<u32>(aligned_bytes), &abcd); - assert!(core::ptr::eq(from_bytes(aligned_bytes), &abcd)); -} - -#[test] -fn test_from_bytes_mut() { - let mut a = 0xaabbccdd_u32; - let a_addr = &a as *const _ as usize; - let aligned_bytes = bytemuck::bytes_of_mut(&mut a); - assert_eq!(*from_bytes_mut::<u32>(aligned_bytes), 0xaabbccdd_u32); - assert_eq!( - from_bytes_mut::<u32>(aligned_bytes) as *const u32 as usize, - a_addr - ); -} - -// like #[should_panic], but can be a part of another test, instead of requiring -// it to be it's own test. -macro_rules! should_panic { - ($ex:expr) => { - assert!( - std::panic::catch_unwind(|| { - let _ = $ex; - }) - .is_err(), - concat!("should have panicked: `", stringify!($ex), "`") - ); - }; -} - -#[test] -fn test_panics() { - should_panic!(cast_slice::<u8, u32>(&[1u8, 2u8])); - should_panic!(cast_slice_mut::<u8, u32>(&mut [1u8, 2u8])); - should_panic!(from_bytes::<u32>(&[1u8, 2])); - should_panic!(from_bytes::<u32>(&[1u8, 2, 3, 4, 5])); - should_panic!(from_bytes_mut::<u32>(&mut [1u8, 2])); - should_panic!(from_bytes_mut::<u32>(&mut [1u8, 2, 3, 4, 5])); - // use cast_slice on some u32s to get some align>=4 bytes, so we can know - // we'll give from_bytes unaligned ones. - let aligned_bytes = bytemuck::cast_slice::<u32, u8>(&[0, 0]); - should_panic!(from_bytes::<u32>(&aligned_bytes[1..5])); -} diff --git a/vendor/bytemuck/tests/checked_tests.rs b/vendor/bytemuck/tests/checked_tests.rs deleted file mode 100644 index c7c5640..0000000 --- a/vendor/bytemuck/tests/checked_tests.rs +++ /dev/null @@ -1,419 +0,0 @@ -#![allow(clippy::unnecessary_cast)] -#![allow(clippy::manual_slice_size_calculation)] - -use core::{ - mem::size_of, - num::{NonZeroU32, NonZeroU8}, -}; - -use bytemuck::{checked::CheckedCastError, *}; - -#[test] -fn test_try_cast_slice() { - // some align4 data - let nonzero_u32_slice: &[NonZeroU32] = &[ - NonZeroU32::new(4).unwrap(), - NonZeroU32::new(5).unwrap(), - NonZeroU32::new(6).unwrap(), - ]; - - // contains bytes with invalid bitpattern for NonZeroU8 - assert_eq!( - checked::try_cast_slice::<NonZeroU32, NonZeroU8>(nonzero_u32_slice), - Err(CheckedCastError::InvalidBitPattern) - ); - - // the same data as align1 - let the_bytes: &[u8] = checked::try_cast_slice(nonzero_u32_slice).unwrap(); - - assert_eq!( - nonzero_u32_slice.as_ptr() as *const NonZeroU32 as usize, - the_bytes.as_ptr() as *const u8 as usize - ); - assert_eq!( - nonzero_u32_slice.len() * size_of::<NonZeroU32>(), - the_bytes.len() * size_of::<u8>() - ); - - // by taking one byte off the front, we're definitely mis-aligned for - // NonZeroU32. - let mis_aligned_bytes = &the_bytes[1..]; - assert_eq!( - checked::try_cast_slice::<u8, NonZeroU32>(mis_aligned_bytes), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); - - // by taking one byte off the end, we're aligned but would have slop bytes for - // NonZeroU32 - let the_bytes_len_minus1 = the_bytes.len() - 1; - let slop_bytes = &the_bytes[..the_bytes_len_minus1]; - assert_eq!( - checked::try_cast_slice::<u8, NonZeroU32>(slop_bytes), - Err(CheckedCastError::PodCastError(PodCastError::OutputSliceWouldHaveSlop)) - ); - - // if we don't mess with it we can up-alignment cast - checked::try_cast_slice::<u8, NonZeroU32>(the_bytes).unwrap(); -} - -#[test] -fn test_try_cast_slice_mut() { - // some align4 data - let u32_slice: &mut [u32] = &mut [4, 5, 6]; - - // contains bytes with invalid bitpattern for NonZeroU8 - assert_eq!( - checked::try_cast_slice_mut::<u32, NonZeroU8>(u32_slice), - Err(CheckedCastError::InvalidBitPattern) - ); - - // some align4 data - let u32_slice: &mut [u32] = &mut [0x4444_4444, 0x5555_5555, 0x6666_6666]; - let u32_len = u32_slice.len(); - let u32_ptr = u32_slice.as_ptr(); - - // the same data as align1, nonzero bytes - let the_nonzero_bytes: &mut [NonZeroU8] = - checked::try_cast_slice_mut(u32_slice).unwrap(); - let the_nonzero_bytes_len = the_nonzero_bytes.len(); - let the_nonzero_bytes_ptr = the_nonzero_bytes.as_ptr(); - - assert_eq!( - u32_ptr as *const u32 as usize, - the_nonzero_bytes_ptr as *const NonZeroU8 as usize - ); - assert_eq!( - u32_len * size_of::<u32>(), - the_nonzero_bytes_len * size_of::<NonZeroU8>() - ); - - // the same data as align1 - let the_bytes: &mut [u8] = checked::try_cast_slice_mut(u32_slice).unwrap(); - let the_bytes_len = the_bytes.len(); - let the_bytes_ptr = the_bytes.as_ptr(); - - assert_eq!( - u32_ptr as *const u32 as usize, - the_bytes_ptr as *const u8 as usize - ); - assert_eq!( - u32_len * size_of::<u32>(), - the_bytes_len * size_of::<NonZeroU8>() - ); - - // by taking one byte off the front, we're definitely mis-aligned for u32. - let mis_aligned_bytes = &mut the_bytes[1..]; - assert_eq!( - checked::try_cast_slice_mut::<u8, NonZeroU32>(mis_aligned_bytes), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); - - // by taking one byte off the end, we're aligned but would have slop bytes for - // NonZeroU32 - let the_bytes_len_minus1 = the_bytes.len() - 1; - let slop_bytes = &mut the_bytes[..the_bytes_len_minus1]; - assert_eq!( - checked::try_cast_slice_mut::<u8, NonZeroU32>(slop_bytes), - Err(CheckedCastError::PodCastError(PodCastError::OutputSliceWouldHaveSlop)) - ); - - // if we don't mess with it we can up-alignment cast, since there are no - // zeroes in the original slice - checked::try_cast_slice_mut::<u8, NonZeroU32>(the_bytes).unwrap(); -} - -#[test] -fn test_types() { - let _: NonZeroU32 = checked::cast(1.0_f32); - let _: &mut NonZeroU32 = checked::cast_mut(&mut 1.0_f32); - let _: &NonZeroU32 = checked::cast_ref(&1.0_f32); - let _: &[NonZeroU32] = checked::cast_slice(&[1.0_f32]); - let _: &mut [NonZeroU32] = checked::cast_slice_mut(&mut [1.0_f32]); - // - let _: Result<NonZeroU32, CheckedCastError> = checked::try_cast(1.0_f32); - let _: Result<&mut NonZeroU32, CheckedCastError> = - checked::try_cast_mut(&mut 1.0_f32); - let _: Result<&NonZeroU32, CheckedCastError> = - checked::try_cast_ref(&1.0_f32); - let _: Result<&[NonZeroU32], CheckedCastError> = - checked::try_cast_slice(&[1.0_f32]); - let _: Result<&mut [NonZeroU32], CheckedCastError> = - checked::try_cast_slice_mut(&mut [1.0_f32]); -} - -#[test] -fn test_try_pod_read_unaligned() { - let u32s = [0xaabbccdd, 0x11223344_u32]; - let bytes = bytemuck::checked::cast_slice::<u32, u8>(&u32s); - - #[cfg(target_endian = "big")] - assert_eq!( - checked::try_pod_read_unaligned::<NonZeroU32>(&bytes[1..5]), - Ok(NonZeroU32::new(0xbbccdd11).unwrap()) - ); - #[cfg(target_endian = "little")] - assert_eq!( - checked::try_pod_read_unaligned::<NonZeroU32>(&bytes[1..5]), - Ok(NonZeroU32::new(0x44aabbcc).unwrap()) - ); - - let u32s = [0; 2]; - let bytes = bytemuck::checked::cast_slice::<u32, u8>(&u32s); - - assert_eq!( - checked::try_pod_read_unaligned::<NonZeroU32>(&bytes[1..5]), - Err(CheckedCastError::InvalidBitPattern) - ); -} - -#[test] -fn test_try_from_bytes() { - let nonzero_u32s = [ - NonZeroU32::new(0xaabbccdd).unwrap(), - NonZeroU32::new(0x11223344).unwrap(), - ]; - let bytes = bytemuck::checked::cast_slice::<NonZeroU32, u8>(&nonzero_u32s); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..4]), - Ok(&nonzero_u32s[0]) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..5]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..3]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[1..5]), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); - - let zero_u32s = [0, 0x11223344_u32]; - let bytes = bytemuck::checked::cast_slice::<u32, u8>(&zero_u32s); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..4]), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[4..]), - Ok(&NonZeroU32::new(zero_u32s[1]).unwrap()) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..5]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[..3]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[1..5]), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); -} - -#[test] -fn test_try_from_bytes_mut() { - let a = 0xaabbccdd_u32; - let b = 0x11223344_u32; - let mut u32s = [a, b]; - let bytes = bytemuck::checked::cast_slice_mut::<u32, u8>(&mut u32s); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..4]), - Ok(&mut NonZeroU32::new(a).unwrap()) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[4..]), - Ok(&mut NonZeroU32::new(b).unwrap()) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..5]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..3]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[1..5]), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); - - let mut u32s = [0, b]; - let bytes = bytemuck::checked::cast_slice_mut::<u32, u8>(&mut u32s); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..4]), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[4..]), - Ok(&mut NonZeroU32::new(b).unwrap()) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..5]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes_mut::<NonZeroU32>(&mut bytes[..3]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); - assert_eq!( - checked::try_from_bytes::<NonZeroU32>(&bytes[1..5]), - Err(CheckedCastError::PodCastError( - PodCastError::TargetAlignmentGreaterAndInputNotAligned - )) - ); -} - -#[test] -fn test_from_bytes() { - let abcd = 0xaabbccdd_u32; - let aligned_bytes = bytemuck::bytes_of(&abcd); - assert_eq!( - checked::from_bytes::<NonZeroU32>(aligned_bytes), - &NonZeroU32::new(abcd).unwrap() - ); - assert!(core::ptr::eq( - checked::from_bytes(aligned_bytes) as *const NonZeroU32 as *const u32, - &abcd - )); -} - -#[test] -fn test_from_bytes_mut() { - let mut a = 0xaabbccdd_u32; - let a_addr = &a as *const _ as usize; - let aligned_bytes = bytemuck::bytes_of_mut(&mut a); - assert_eq!( - *checked::from_bytes_mut::<NonZeroU32>(aligned_bytes), - NonZeroU32::new(0xaabbccdd).unwrap() - ); - assert_eq!( - checked::from_bytes_mut::<NonZeroU32>(aligned_bytes) as *const NonZeroU32 - as usize, - a_addr - ); -} - -// like #[should_panic], but can be a part of another test, instead of requiring -// it to be it's own test. -macro_rules! should_panic { - ($ex:expr) => { - assert!( - std::panic::catch_unwind(|| { - let _ = $ex; - }) - .is_err(), - concat!("should have panicked: `", stringify!($ex), "`") - ); - }; -} - -#[test] -fn test_panics() { - should_panic!(checked::cast::<u32, NonZeroU32>(0)); - should_panic!(checked::cast_ref::<u32, NonZeroU32>(&0)); - should_panic!(checked::cast_mut::<u32, NonZeroU32>(&mut 0)); - should_panic!(checked::cast_slice::<u8, NonZeroU32>(&[1u8, 2u8])); - should_panic!(checked::cast_slice_mut::<u8, NonZeroU32>(&mut [1u8, 2u8])); - should_panic!(checked::from_bytes::<NonZeroU32>(&[1u8, 2])); - should_panic!(checked::from_bytes::<NonZeroU32>(&[1u8, 2, 3, 4, 5])); - should_panic!(checked::from_bytes_mut::<NonZeroU32>(&mut [1u8, 2])); - should_panic!(checked::from_bytes_mut::<NonZeroU32>(&mut [1u8, 2, 3, 4, 5])); - // use cast_slice on some u32s to get some align>=4 bytes, so we can know - // we'll give from_bytes unaligned ones. - let aligned_bytes = bytemuck::cast_slice::<u32, u8>(&[0, 0]); - should_panic!(checked::from_bytes::<NonZeroU32>(aligned_bytes)); - should_panic!(checked::from_bytes::<NonZeroU32>(&aligned_bytes[1..5])); - should_panic!(checked::pod_read_unaligned::<NonZeroU32>( - &aligned_bytes[1..5] - )); -} - -#[test] -fn test_char() { - assert_eq!(checked::try_cast::<u32, char>(0), Ok('\0')); - assert_eq!(checked::try_cast::<u32, char>(0xd7ff), Ok('\u{d7ff}')); - assert_eq!( - checked::try_cast::<u32, char>(0xd800), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_cast::<u32, char>(0xdfff), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!(checked::try_cast::<u32, char>(0xe000), Ok('\u{e000}')); - assert_eq!(checked::try_cast::<u32, char>(0x10ffff), Ok('\u{10ffff}')); - assert_eq!( - checked::try_cast::<u32, char>(0x110000), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_cast::<u32, char>(-1i32 as u32), - Err(CheckedCastError::InvalidBitPattern) - ); -} - -#[test] -fn test_bool() { - assert_eq!(checked::try_cast::<u8, bool>(0), Ok(false)); - assert_eq!(checked::try_cast::<u8, bool>(1), Ok(true)); - for i in 2..=255 { - assert_eq!( - checked::try_cast::<u8, bool>(i), - Err(CheckedCastError::InvalidBitPattern) - ); - } - - assert_eq!(checked::try_from_bytes::<bool>(&[1]), Ok(&true)); - assert_eq!( - checked::try_from_bytes::<bool>(&[3]), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_from_bytes::<bool>(&[0, 1]), - Err(CheckedCastError::PodCastError(PodCastError::SizeMismatch)) - ); -} - -#[test] -fn test_all_nonzero() { - use core::num::*; - macro_rules! test_nonzero { - ($nonzero:ty: $primitive:ty) => { - assert_eq!( - checked::try_cast::<$primitive, $nonzero>(0), - Err(CheckedCastError::InvalidBitPattern) - ); - assert_eq!( - checked::try_cast::<$primitive, $nonzero>(1), - Ok(<$nonzero>::new(1).unwrap()) - ); - }; - } - - test_nonzero!(NonZeroU8: u8); - test_nonzero!(NonZeroI8: i8); - test_nonzero!(NonZeroU16: u16); - test_nonzero!(NonZeroI16: i16); - test_nonzero!(NonZeroU32: u32); - test_nonzero!(NonZeroI32: i32); - test_nonzero!(NonZeroU64: u64); - test_nonzero!(NonZeroI64: i64); - test_nonzero!(NonZeroU128: u128); - test_nonzero!(NonZeroI128: i128); - test_nonzero!(NonZeroUsize: usize); - test_nonzero!(NonZeroIsize: isize); -} diff --git a/vendor/bytemuck/tests/derive.rs b/vendor/bytemuck/tests/derive.rs deleted file mode 100644 index 1c6b10e..0000000 --- a/vendor/bytemuck/tests/derive.rs +++ /dev/null @@ -1,77 +0,0 @@ -#![cfg(feature = "derive")] -#![allow(dead_code)] - -use bytemuck::{ByteEq, ByteHash, Pod, TransparentWrapper, Zeroable}; -use std::marker::PhantomData; - -#[derive(Copy, Clone, Pod, Zeroable, ByteEq, ByteHash)] -#[repr(C)] -struct Test { - a: u16, - b: u16, -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -struct TransparentSingle { - a: u16, -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -#[transparent(u16)] -struct TransparentWithZeroSized { - a: u16, - b: (), -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -struct TransparentWithGeneric<T: ?Sized> { - a: T, -} - -/// Ensuring that no additional bounds are emitted. -/// See https://github.com/Lokathor/bytemuck/issues/145 -fn test_generic<T>(x: T) -> TransparentWithGeneric<T> { - TransparentWithGeneric::wrap(x) -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -#[transparent(T)] -struct TransparentWithGenericAndZeroSized<T: ?Sized> { - a: (), - b: T, -} - -/// Ensuring that no additional bounds are emitted. -/// See https://github.com/Lokathor/bytemuck/issues/145 -fn test_generic_with_zst<T>(x: T) -> TransparentWithGenericAndZeroSized<T> { - TransparentWithGenericAndZeroSized::wrap(x) -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -struct TransparentUnsized { - a: dyn std::fmt::Debug, -} - -type DynDebug = dyn std::fmt::Debug; - -#[derive(TransparentWrapper)] -#[repr(transparent)] -#[transparent(DynDebug)] -struct TransparentUnsizedWithZeroSized { - a: (), - b: DynDebug, -} - -#[derive(TransparentWrapper)] -#[repr(transparent)] -#[transparent(DynDebug)] -struct TransparentUnsizedWithGenericZeroSizeds<T: ?Sized, U: ?Sized> { - a: PhantomData<T>, - b: PhantomData<U>, - c: DynDebug, -} diff --git a/vendor/bytemuck/tests/doc_tests.rs b/vendor/bytemuck/tests/doc_tests.rs deleted file mode 100644 index d08e970..0000000 --- a/vendor/bytemuck/tests/doc_tests.rs +++ /dev/null @@ -1,123 +0,0 @@ -#![allow(clippy::disallowed_names)] - -//! Cargo miri doesn't run doctests yet, so we duplicate these here. It's -//! probably not that important to sweat keeping these perfectly up to date, but -//! we should try to catch the cases where the primary tests are doctests. -use bytemuck::*; - -// Miri doesn't run on doctests, so... copypaste to the rescue. -#[test] -fn test_transparent_slice() { - #[repr(transparent)] - struct Slice<T>([T]); - - unsafe impl<T> TransparentWrapper<[T]> for Slice<T> {} - - let s = Slice::wrap_ref(&[1u32, 2, 3]); - assert_eq!(&s.0, &[1, 2, 3]); - - let mut buf = [1, 2, 3u8]; - let _sm = Slice::wrap_mut(&mut buf); -} - -#[test] -fn test_transparent_basic() { - #[derive(Default)] - struct SomeStruct(u32); - - #[repr(transparent)] - struct MyWrapper(SomeStruct); - - unsafe impl TransparentWrapper<SomeStruct> for MyWrapper {} - - // interpret a reference to &SomeStruct as a &MyWrapper - let thing = SomeStruct::default(); - let wrapped_ref: &MyWrapper = MyWrapper::wrap_ref(&thing); - - // Works with &mut too. - let mut mut_thing = SomeStruct::default(); - let wrapped_mut: &mut MyWrapper = MyWrapper::wrap_mut(&mut mut_thing); - let _ = (wrapped_ref, wrapped_mut); -} - -// Work around miri not running doctests -#[test] -fn test_contiguous_doc() { - #[repr(u8)] - #[derive(Debug, Copy, Clone, PartialEq)] - enum Foo { - A = 0, - B = 1, - C = 2, - D = 3, - E = 4, - } - unsafe impl Contiguous for Foo { - type Int = u8; - const MIN_VALUE: u8 = Foo::A as u8; - const MAX_VALUE: u8 = Foo::E as u8; - } - - assert_eq!(Foo::from_integer(3).unwrap(), Foo::D); - assert_eq!(Foo::from_integer(8), None); - assert_eq!(Foo::C.into_integer(), 2); - assert_eq!(Foo::B.into_integer(), Foo::B as u8); -} - -#[test] -fn test_offsetof_vertex() { - #[repr(C)] - struct Vertex { - pos: [f32; 2], - uv: [u16; 2], - color: [u8; 4], - } - unsafe impl Zeroable for Vertex {} - - let pos = offset_of!(Zeroable::zeroed(), Vertex, pos); - let uv = offset_of!(Zeroable::zeroed(), Vertex, uv); - let color = offset_of!(Zeroable::zeroed(), Vertex, color); - - assert_eq!(pos, 0); - assert_eq!(uv, 8); - assert_eq!(color, 12); -} - -#[test] -fn test_offsetof_nonpod() { - #[derive(Default)] - struct Foo { - a: u8, - b: &'static str, - c: i32, - } - - let a_offset = offset_of!(Default::default(), Foo, a); - let b_offset = offset_of!(Default::default(), Foo, b); - let c_offset = offset_of!(Default::default(), Foo, c); - - assert_ne!(a_offset, b_offset); - assert_ne!(b_offset, c_offset); - // We can't check against hardcoded values for a repr(Rust) type, - // but prove to ourself this way. - - let foo = Foo::default(); - // Note: offsets are in bytes. - let as_bytes = &foo as *const _ as *const u8; - - // We're using wrapping_offset here because it's not worth - // the unsafe block, but it would be valid to use `add` instead, - // as it cannot overflow. - assert_eq!( - &foo.a as *const _ as usize, - as_bytes.wrapping_add(a_offset) as usize - ); - assert_eq!( - &foo.b as *const _ as usize, - as_bytes.wrapping_add(b_offset) as usize - ); - assert_eq!( - &foo.c as *const _ as usize, - as_bytes.wrapping_add(c_offset) as usize - ); -} diff --git a/vendor/bytemuck/tests/offset_of_tests.rs b/vendor/bytemuck/tests/offset_of_tests.rs deleted file mode 100644 index 4cad5d4..0000000 --- a/vendor/bytemuck/tests/offset_of_tests.rs +++ /dev/null @@ -1,60 +0,0 @@ -#![allow(clippy::disallowed_names)] -use bytemuck::{offset_of, Zeroable}; - -#[test] -fn test_offset_of_vertex() { - #[repr(C)] - struct Vertex { - pos: [f32; 2], - uv: [u16; 2], - color: [u8; 4], - } - unsafe impl Zeroable for Vertex {} - - let pos = offset_of!(Zeroable::zeroed(), Vertex, pos); - let uv = offset_of!(Zeroable::zeroed(), Vertex, uv); - let color = offset_of!(Zeroable::zeroed(), Vertex, color); - - assert_eq!(pos, 0); - assert_eq!(uv, 8); - assert_eq!(color, 12); -} - -#[test] -fn test_offset_of_foo() { - #[derive(Default)] - struct Foo { - a: u8, - b: &'static str, - c: i32, - } - - let a_offset = offset_of!(Default::default(), Foo, a); - let b_offset = offset_of!(Default::default(), Foo, b); - let c_offset = offset_of!(Default::default(), Foo, c); - - assert_ne!(a_offset, b_offset); - assert_ne!(b_offset, c_offset); - // We can't check against hardcoded values for a repr(Rust) type, - // but prove to ourself this way. - - let foo = Foo::default(); - // Note: offsets are in bytes. - let as_bytes = &foo as *const _ as *const u8; - - // we're using wrapping_offset here because it's not worth - // the unsafe block, but it would be valid to use `add` instead, - // as it cannot overflow. - assert_eq!( - &foo.a as *const _ as usize, - as_bytes.wrapping_add(a_offset) as usize - ); - assert_eq!( - &foo.b as *const _ as usize, - as_bytes.wrapping_add(b_offset) as usize - ); - assert_eq!( - &foo.c as *const _ as usize, - as_bytes.wrapping_add(c_offset) as usize - ); -} diff --git a/vendor/bytemuck/tests/std_tests.rs b/vendor/bytemuck/tests/std_tests.rs deleted file mode 100644 index e239058..0000000 --- a/vendor/bytemuck/tests/std_tests.rs +++ /dev/null @@ -1,46 +0,0 @@ -#![allow(clippy::uninlined_format_args)] -//! The integration tests seem to always have `std` linked, so things that would -//! depend on that can go here. - -use bytemuck::*; - -#[test] -fn test_transparent_vtabled() { - use core::fmt::Display; - - #[repr(transparent)] - struct DisplayTraitObj(dyn Display); - - unsafe impl TransparentWrapper<dyn Display> for DisplayTraitObj {} - - impl Display for DisplayTraitObj { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - self.0.fmt(f) - } - } - - let v = DisplayTraitObj::wrap_ref(&5i32); - let s = format!("{}", v); - assert_eq!(s, "5"); - - let mut x = 100i32; - let v_mut = DisplayTraitObj::wrap_mut(&mut x); - let s = format!("{}", v_mut); - assert_eq!(s, "100"); -} - -#[test] -#[cfg(feature = "extern_crate_alloc")] -fn test_large_box_alloc() { - type SuperPage = [[u8; 4096]; 4096]; - let _: Box<SuperPage> = try_zeroed_box().unwrap(); -} - -#[test] -#[cfg(feature = "extern_crate_alloc")] -fn test_zero_sized_box_alloc() { - #[repr(align(4096))] - struct Empty; - unsafe impl Zeroable for Empty {} - let _: Box<Empty> = try_zeroed_box().unwrap(); -} diff --git a/vendor/bytemuck/tests/transparent.rs b/vendor/bytemuck/tests/transparent.rs deleted file mode 100644 index be26c21..0000000 --- a/vendor/bytemuck/tests/transparent.rs +++ /dev/null @@ -1,116 +0,0 @@ -// Currently this test doesn't actually check the output of the functions. -// It's only here for miri to check for any potential undefined behaviour. -// TODO: check function results - -#[test] -fn test_transparent_wrapper() { - // An external type defined in a different crate. - #[derive(Debug, Copy, Clone, Default)] - struct Foreign(u8); - - use bytemuck::TransparentWrapper; - - #[derive(Debug, Copy, Clone)] - #[repr(transparent)] - struct Wrapper(Foreign); - - unsafe impl TransparentWrapper<Foreign> for Wrapper {} - - // Traits can be implemented on crate-local wrapper. - unsafe impl bytemuck::Zeroable for Wrapper {} - unsafe impl bytemuck::Pod for Wrapper {} - - impl PartialEq<u8> for Foreign { - fn eq(&self, &other: &u8) -> bool { - self.0 == other - } - } - - impl PartialEq<u8> for Wrapper { - fn eq(&self, &other: &u8) -> bool { - self.0 == other - } - } - - let _: u8 = bytemuck::cast(Wrapper::wrap(Foreign::default())); - let _: Foreign = Wrapper::peel(bytemuck::cast(u8::default())); - - let _: &u8 = bytemuck::cast_ref(Wrapper::wrap_ref(&Foreign::default())); - let _: &Foreign = Wrapper::peel_ref(bytemuck::cast_ref(&u8::default())); - - let _: &mut u8 = - bytemuck::cast_mut(Wrapper::wrap_mut(&mut Foreign::default())); - let _: &mut Foreign = - Wrapper::peel_mut(bytemuck::cast_mut(&mut u8::default())); - - let _: &[u8] = - bytemuck::cast_slice(Wrapper::wrap_slice(&[Foreign::default()])); - let _: &[Foreign] = - Wrapper::peel_slice(bytemuck::cast_slice(&[u8::default()])); - - let _: &mut [u8] = - bytemuck::cast_slice_mut(Wrapper::wrap_slice_mut( - &mut [Foreign::default()], - )); - let _: &mut [Foreign] = - Wrapper::peel_slice_mut(bytemuck::cast_slice_mut(&mut [u8::default()])); - - let _: &[u8] = bytemuck::bytes_of(Wrapper::wrap_ref(&Foreign::default())); - let _: &Foreign = Wrapper::peel_ref(bytemuck::from_bytes(&[u8::default()])); - - let _: &mut [u8] = - bytemuck::bytes_of_mut(Wrapper::wrap_mut(&mut Foreign::default())); - let _: &mut Foreign = - Wrapper::peel_mut(bytemuck::from_bytes_mut(&mut [u8::default()])); - - // not sure if this is the right usage - let _ = - bytemuck::pod_align_to::<_, u8>(Wrapper::wrap_slice(&[Foreign::default()])); - // counterpart? - - // not sure if this is the right usage - let _ = bytemuck::pod_align_to_mut::<_, u8>(Wrapper::wrap_slice_mut(&mut [ - Foreign::default(), - ])); - // counterpart? - - #[cfg(feature = "extern_crate_alloc")] - { - use bytemuck::allocation::TransparentWrapperAlloc; - use std::rc::Rc; - - let a: Vec<Foreign> = vec![Foreign::default(); 2]; - - let b: Vec<Wrapper> = Wrapper::wrap_vec(a); - assert_eq!(b, [0, 0]); - - let c: Vec<Foreign> = Wrapper::peel_vec(b); - assert_eq!(c, [0, 0]); - - let d: Box<Foreign> = Box::new(Foreign::default()); - - let e: Box<Wrapper> = Wrapper::wrap_box(d); - assert_eq!(&*e, &0); - let f: Box<Foreign> = Wrapper::peel_box(e); - assert_eq!(&*f, &0); - - let g: Rc<Foreign> = Rc::new(Foreign::default()); - - let h: Rc<Wrapper> = Wrapper::wrap_rc(g); - assert_eq!(&*h, &0); - let i: Rc<Foreign> = Wrapper::peel_rc(h); - assert_eq!(&*i, &0); - - #[cfg(target_has_atomic = "ptr")] - { - use std::sync::Arc; - - let j: Arc<Foreign> = Arc::new(Foreign::default()); - - let k: Arc<Wrapper> = Wrapper::wrap_arc(j); - assert_eq!(&*k, &0); - let l: Arc<Foreign> = Wrapper::peel_arc(k); - assert_eq!(&*l, &0); - } - } -} diff --git a/vendor/bytemuck/tests/wrapper_forgets.rs b/vendor/bytemuck/tests/wrapper_forgets.rs deleted file mode 100644 index 5484744..0000000 --- a/vendor/bytemuck/tests/wrapper_forgets.rs +++ /dev/null @@ -1,13 +0,0 @@ -use bytemuck::TransparentWrapper; - -#[repr(transparent)] -struct Wrap(Box<u32>); - -// SAFETY: it's #[repr(transparent)] -unsafe impl TransparentWrapper<Box<u32>> for Wrap {} - -fn main() { - let value = Box::new(5); - // This used to duplicate the wrapped value, creating a double free :( - Wrap::wrap(value); -} |