Source code
Revision control
Copy as Markdown
Other Tools
#![allow(clippy::disallowed_names)]↩
#![allow(dead_code)]↩
↩
//! 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↩
);↩
}↩