diff --git a/src/transparent.rs b/src/transparent.rs index 0b7fbfb..b77a870 100644 --- a/src/transparent.rs +++ b/src/transparent.rs @@ -98,7 +98,7 @@ pub unsafe trait TransparentWrapper { // // SAFETY: The unsafe contract requires that these have identical // representations. Using this transmute_copy instead of transmute here is - // annoying, but is required as `Self` and `Self::Int` have unspecified + // annoying, but is required as `Self` and `Wrapped` have unspecified // sizes still. let wrapped_ptr = s as *const Wrapped; let wrapper_ptr: *const Self = transmute_copy(&wrapped_ptr); @@ -123,7 +123,7 @@ pub unsafe trait TransparentWrapper { // // SAFETY: The unsafe contract requires that these have identical // representations. Using this transmute_copy instead of transmute here is - // annoying, but is required as `Self` and `Self::Int` have unspecified + // annoying, but is required as `Self` and `Wrapped` have unspecified // sizes still. let wrapped_ptr = s as *mut Wrapped; let wrapper_ptr: *mut Self = transmute_copy(&wrapped_ptr); @@ -131,34 +131,3 @@ pub unsafe trait TransparentWrapper { } } } - -#[cfg(all(test, feature = "extern_crate_alloc"))] -mod test { - use super::*; - - use alloc::format; - use core::fmt::Display; - - #[repr(transparent)] - struct DisplayTraitObj(dyn Display); - - unsafe impl TransparentWrapper for DisplayTraitObj {} - - impl Display for DisplayTraitObj { - fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - self.0.fmt(f) - } - } - - #[test] - fn test_vtabled() { - 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"); - } -} diff --git a/tests/doc_tests.rs b/tests/doc_tests.rs new file mode 100644 index 0000000..e5a80db --- /dev/null +++ b/tests/doc_tests.rs @@ -0,0 +1,121 @@ +//! 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]); + + unsafe impl TransparentWrapper<[T]> for Slice {} + + 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 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 becasue 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/tests/std_tests.rs b/tests/std_tests.rs new file mode 100644 index 0000000..0e0fb48 --- /dev/null +++ b/tests/std_tests.rs @@ -0,0 +1,29 @@ +//! 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 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"); +}