mirror of
https://github.com/Lokathor/bytemuck.git
synced 2024-11-21 22:32:23 +00:00
02021fba24
Apparently the latest release of `bytemuck` doesn't compile on some of the targets that it used to because it uses `Arc`. `Arc` is not a type that exists on every target, because not every targets supports atomics.
117 lines
3.3 KiB
Rust
117 lines
3.3 KiB
Rust
// 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);
|
|
}
|
|
}
|
|
}
|