4 #[cfg(panic = "unwind")]
9 assert_eq!(size_of::<u8>(), 1);
10 assert_eq!(size_of::<u16>(), 2);
11 assert_eq!(size_of::<u32>(), 4);
12 assert_eq!(size_of::<u64>(), 8);
16 #[cfg(target_pointer_width = "16")]
18 assert_eq!(size_of::<usize>(), 2);
19 assert_eq!(size_of::<*const usize>(), 2);
23 #[cfg(target_pointer_width = "32")]
25 assert_eq!(size_of::<usize>(), 4);
26 assert_eq!(size_of::<*const usize>(), 4);
30 #[cfg(target_pointer_width = "64")]
32 assert_eq!(size_of::<usize>(), 8);
33 assert_eq!(size_of::<*const usize>(), 8);
37 fn size_of_val_basic() {
38 assert_eq!(size_of_val(&1u8), 1);
39 assert_eq!(size_of_val(&1u16), 2);
40 assert_eq!(size_of_val(&1u32), 4);
41 assert_eq!(size_of_val(&1u64), 8);
46 assert_eq!(align_of::<u8>(), 1);
47 assert_eq!(align_of::<u16>(), 2);
48 assert_eq!(align_of::<u32>(), 4);
52 #[cfg(target_pointer_width = "16")]
54 assert_eq!(align_of::<usize>(), 2);
55 assert_eq!(align_of::<*const usize>(), 2);
59 #[cfg(target_pointer_width = "32")]
61 assert_eq!(align_of::<usize>(), 4);
62 assert_eq!(align_of::<*const usize>(), 4);
66 #[cfg(target_pointer_width = "64")]
68 assert_eq!(align_of::<usize>(), 8);
69 assert_eq!(align_of::<*const usize>(), 8);
73 fn align_of_val_basic() {
74 assert_eq!(align_of_val(&1u8), 1);
75 assert_eq!(align_of_val(&1u16), 2);
76 assert_eq!(align_of_val(&1u32), 4);
80 #[cfg(not(bootstrap))] // stage 0 doesn't have the fix yet, so the test fails
81 fn align_of_val_raw_packed() {
86 let storage = [0u8; 4];
87 let b: *const B = ptr::from_raw_parts(storage.as_ptr().cast(), 1);
88 assert_eq!(unsafe { align_of_val_raw(b) }, 1);
90 const ALIGN_OF_VAL_RAW: usize = {
91 let storage = [0u8; 4];
92 let b: *const B = ptr::from_raw_parts(storage.as_ptr().cast(), 1);
93 unsafe { align_of_val_raw(b) }
95 assert_eq!(ALIGN_OF_VAL_RAW, 1);
102 swap(&mut x, &mut y);
104 assert_eq!(y, 31337);
109 let mut x = Some("test".to_string());
110 let y = replace(&mut x, None);
111 assert!(x.is_none());
112 assert!(y.is_some());
116 fn test_transmute_copy() {
117 assert_eq!(1, unsafe { transmute_copy(&1) });
121 fn test_transmute_copy_shrink() {
122 assert_eq!(0_u8, unsafe { transmute_copy(&0_u64) });
126 fn test_transmute_copy_unaligned() {
134 let u = Unaligned::default();
135 assert_eq!(0_u64, unsafe { transmute_copy(&u.b) });
139 #[cfg(panic = "unwind")]
140 fn test_transmute_copy_grow_panics() {
143 let err = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
144 let _unused: u64 = transmute_copy(&1_u8);
148 Ok(_) => unreachable!(),
151 .downcast::<&'static str>()
153 if *s == "cannot transmute_copy if Dst is larger than Src" {
159 .unwrap_or_else(|p| panic::resume_unwind(p));
166 fn test_discriminant_send_sync() {
175 fn is_send_sync<T: Send + Sync>() {}
177 is_send_sync::<Discriminant<Regular>>();
178 is_send_sync::<Discriminant<NotSendSync>>();
182 fn assume_init_good() {
183 const TRUE: bool = unsafe { MaybeUninit::<bool>::new(true).assume_init() };
189 fn uninit_array_assume_init() {
190 let mut array = [MaybeUninit::<i16>::uninit(); 5];
197 let array = unsafe { array.transpose().assume_init() };
199 assert_eq!(array, [3, 1, 4, 1, 5]);
201 let [] = unsafe { [MaybeUninit::<!>::uninit(); 0].transpose().assume_init() };
205 fn uninit_write_slice() {
206 let mut dst = [MaybeUninit::new(255); 64];
209 assert_eq!(MaybeUninit::write_slice(&mut dst, &src), &src);
213 #[should_panic(expected = "source slice length (32) does not match destination slice length (64)")]
214 fn uninit_write_slice_panic_lt() {
215 let mut dst = [MaybeUninit::uninit(); 64];
218 MaybeUninit::write_slice(&mut dst, &src);
222 #[should_panic(expected = "source slice length (128) does not match destination slice length (64)")]
223 fn uninit_write_slice_panic_gt() {
224 let mut dst = [MaybeUninit::uninit(); 64];
227 MaybeUninit::write_slice(&mut dst, &src);
231 fn uninit_clone_from_slice() {
232 let mut dst = [MaybeUninit::new(255); 64];
235 assert_eq!(MaybeUninit::write_slice_cloned(&mut dst, &src), &src);
239 #[should_panic(expected = "destination and source slices have different lengths")]
240 fn uninit_write_slice_cloned_panic_lt() {
241 let mut dst = [MaybeUninit::uninit(); 64];
244 MaybeUninit::write_slice_cloned(&mut dst, &src);
248 #[should_panic(expected = "destination and source slices have different lengths")]
249 fn uninit_write_slice_cloned_panic_gt() {
250 let mut dst = [MaybeUninit::uninit(); 64];
253 MaybeUninit::write_slice_cloned(&mut dst, &src);
257 #[cfg(panic = "unwind")]
258 fn uninit_write_slice_cloned_mid_panic() {
261 enum IncrementOrPanic {
267 impl Clone for IncrementOrPanic {
268 fn clone(&self) -> Self {
270 Self::Increment(rc) => Self::Increment(rc.clone()),
271 Self::ExpectedPanic => panic!("expected panic on clone"),
272 Self::UnexpectedPanic => panic!("unexpected panic on clone"),
277 let rc = Rc::new(());
280 MaybeUninit::uninit(),
281 MaybeUninit::uninit(),
282 MaybeUninit::uninit(),
283 MaybeUninit::uninit(),
287 IncrementOrPanic::Increment(rc.clone()),
288 IncrementOrPanic::Increment(rc.clone()),
289 IncrementOrPanic::ExpectedPanic,
290 IncrementOrPanic::UnexpectedPanic,
293 let err = panic::catch_unwind(panic::AssertUnwindSafe(|| {
294 MaybeUninit::write_slice_cloned(&mut dst, &src);
300 Ok(_) => unreachable!(),
303 .downcast::<&'static str>()
304 .and_then(|s| if *s == "expected panic on clone" { Ok(s) } else { Err(s) })
305 .unwrap_or_else(|p| panic::resume_unwind(p));
307 assert_eq!(Rc::strong_count(&rc), 1)
313 fn uninit_write_slice_cloned_no_drop() {
319 panic!("dropped a bomb! kaboom")
323 let mut dst = [MaybeUninit::uninit()];
326 MaybeUninit::write_slice_cloned(&mut dst, &src);
332 fn uninit_const_assume_init_read() {
333 const FOO: u32 = unsafe { MaybeUninit::new(42).assume_init_read() };
338 fn const_maybe_uninit() {
341 #[derive(Debug, PartialEq)]
347 const FIELD_BY_FIELD: Foo = unsafe {
348 let mut val = MaybeUninit::uninit();
349 init_y(&mut val); // order shouldn't matter
354 const fn init_x(foo: &mut MaybeUninit<Foo>) {
356 *ptr::addr_of_mut!((*foo.as_mut_ptr()).x) = 1;
360 const fn init_y(foo: &mut MaybeUninit<Foo>) {
362 *ptr::addr_of_mut!((*foo.as_mut_ptr()).y) = 2;
366 assert_eq!(FIELD_BY_FIELD, Foo { x: 1, y: 2 });