150 lines
3.0 KiB
Rust
150 lines
3.0 KiB
Rust
use core::mem::*;
|
|
|
|
#[test]
|
|
fn size_of_basic() {
|
|
assert_eq!(size_of::<u8>(), 1);
|
|
assert_eq!(size_of::<u16>(), 2);
|
|
assert_eq!(size_of::<u32>(), 4);
|
|
assert_eq!(size_of::<u64>(), 8);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "16")]
|
|
fn size_of_16() {
|
|
assert_eq!(size_of::<usize>(), 2);
|
|
assert_eq!(size_of::<*const usize>(), 2);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "32")]
|
|
fn size_of_32() {
|
|
assert_eq!(size_of::<usize>(), 4);
|
|
assert_eq!(size_of::<*const usize>(), 4);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "64")]
|
|
fn size_of_64() {
|
|
assert_eq!(size_of::<usize>(), 8);
|
|
assert_eq!(size_of::<*const usize>(), 8);
|
|
}
|
|
|
|
#[test]
|
|
fn size_of_val_basic() {
|
|
assert_eq!(size_of_val(&1u8), 1);
|
|
assert_eq!(size_of_val(&1u16), 2);
|
|
assert_eq!(size_of_val(&1u32), 4);
|
|
assert_eq!(size_of_val(&1u64), 8);
|
|
}
|
|
|
|
#[test]
|
|
fn align_of_basic() {
|
|
assert_eq!(align_of::<u8>(), 1);
|
|
assert_eq!(align_of::<u16>(), 2);
|
|
assert_eq!(align_of::<u32>(), 4);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "16")]
|
|
fn align_of_16() {
|
|
assert_eq!(align_of::<usize>(), 2);
|
|
assert_eq!(align_of::<*const usize>(), 2);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "32")]
|
|
fn align_of_32() {
|
|
assert_eq!(align_of::<usize>(), 4);
|
|
assert_eq!(align_of::<*const usize>(), 4);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(target_pointer_width = "64")]
|
|
fn align_of_64() {
|
|
assert_eq!(align_of::<usize>(), 8);
|
|
assert_eq!(align_of::<*const usize>(), 8);
|
|
}
|
|
|
|
#[test]
|
|
fn align_of_val_basic() {
|
|
assert_eq!(align_of_val(&1u8), 1);
|
|
assert_eq!(align_of_val(&1u16), 2);
|
|
assert_eq!(align_of_val(&1u32), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn test_swap() {
|
|
let mut x = 31337;
|
|
let mut y = 42;
|
|
swap(&mut x, &mut y);
|
|
assert_eq!(x, 42);
|
|
assert_eq!(y, 31337);
|
|
}
|
|
|
|
#[test]
|
|
fn test_replace() {
|
|
let mut x = Some("test".to_string());
|
|
let y = replace(&mut x, None);
|
|
assert!(x.is_none());
|
|
assert!(y.is_some());
|
|
}
|
|
|
|
#[test]
|
|
fn test_transmute_copy() {
|
|
assert_eq!(1, unsafe { transmute_copy(&1) });
|
|
}
|
|
|
|
#[test]
|
|
fn test_transmute() {
|
|
trait Foo {
|
|
fn dummy(&self) {}
|
|
}
|
|
impl Foo for isize {}
|
|
|
|
let a = box 100isize as Box<dyn Foo>;
|
|
unsafe {
|
|
let x: ::core::raw::TraitObject = transmute(a);
|
|
assert!(*(x.data as *const isize) == 100);
|
|
let _x: Box<dyn Foo> = transmute(x);
|
|
}
|
|
|
|
unsafe {
|
|
assert_eq!(transmute::<_, Vec<u8>>("L".to_string()), [76]);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
#[allow(dead_code)]
|
|
fn test_discriminant_send_sync() {
|
|
enum Regular {
|
|
A,
|
|
B(i32),
|
|
}
|
|
enum NotSendSync {
|
|
A(*const i32),
|
|
}
|
|
|
|
fn is_send_sync<T: Send + Sync>() {}
|
|
|
|
is_send_sync::<Discriminant<Regular>>();
|
|
is_send_sync::<Discriminant<NotSendSync>>();
|
|
}
|
|
|
|
#[test]
|
|
fn assume_init_good() {
|
|
const TRUE: bool = unsafe {
|
|
let mut x = MaybeUninit::<bool>::uninit();
|
|
x.as_mut_ptr().write(true);
|
|
x.assume_init()
|
|
};
|
|
assert!(TRUE);
|
|
}
|
|
|
|
#[test]
|
|
#[should_panic]
|
|
fn assume_init_bad() {
|
|
const BAD: () = unsafe {
|
|
MaybeUninit::<!>::uninit().assume_init();
|
|
};
|
|
}
|