mirror of
https://github.com/Lokathor/bytemuck.git
synced 2024-11-25 00:02:22 +00:00
125 lines
3.1 KiB
Rust
125 lines
3.1 KiB
Rust
#![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
|
|
);
|
|
}
|