3 #[cfg(panic = "unwind")]
8 assert_eq!(size_of::<u8>(), 1);
9 assert_eq!(size_of::<u16>(), 2);
10 assert_eq!(size_of::<u32>(), 4);
11 assert_eq!(size_of::<u64>(), 8);
15 #[cfg(target_pointer_width = "16")]
17 assert_eq!(size_of::<usize>(), 2);
18 assert_eq!(size_of::<*const usize>(), 2);
22 #[cfg(target_pointer_width = "32")]
24 assert_eq!(size_of::<usize>(), 4);
25 assert_eq!(size_of::<*const usize>(), 4);
29 #[cfg(target_pointer_width = "64")]
31 assert_eq!(size_of::<usize>(), 8);
32 assert_eq!(size_of::<*const usize>(), 8);
36 fn size_of_val_basic() {
37 assert_eq!(size_of_val(&1u8), 1);
38 assert_eq!(size_of_val(&1u16), 2);
39 assert_eq!(size_of_val(&1u32), 4);
40 assert_eq!(size_of_val(&1u64), 8);
45 assert_eq!(align_of::<u8>(), 1);
46 assert_eq!(align_of::<u16>(), 2);
47 assert_eq!(align_of::<u32>(), 4);
51 #[cfg(target_pointer_width = "16")]
53 assert_eq!(align_of::<usize>(), 2);
54 assert_eq!(align_of::<*const usize>(), 2);
58 #[cfg(target_pointer_width = "32")]
60 assert_eq!(align_of::<usize>(), 4);
61 assert_eq!(align_of::<*const usize>(), 4);
65 #[cfg(target_pointer_width = "64")]
67 assert_eq!(align_of::<usize>(), 8);
68 assert_eq!(align_of::<*const usize>(), 8);
72 fn align_of_val_basic() {
73 assert_eq!(align_of_val(&1u8), 1);
74 assert_eq!(align_of_val(&1u16), 2);
75 assert_eq!(align_of_val(&1u32), 4);
89 let mut x = Some("test".to_string());
90 let y = replace(&mut x, None);
96 fn test_transmute_copy() {
97 assert_eq!(1, unsafe { transmute_copy(&1) });
101 fn test_transmute_copy_shrink() {
102 assert_eq!(0_u8, unsafe { transmute_copy(&0_u64) });
106 fn test_transmute_copy_unaligned() {
114 let u = Unaligned::default();
115 assert_eq!(0_u64, unsafe { transmute_copy(&u.b) });
119 #[cfg(panic = "unwind")]
120 fn test_transmute_copy_grow_panics() {
123 let err = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
124 let _unused: u64 = transmute_copy(&1_u8);
128 Ok(_) => unreachable!(),
131 .downcast::<&'static str>()
133 if *s == "cannot transmute_copy if Dst is larger than Src" {
139 .unwrap_or_else(|p| panic::resume_unwind(p));
146 fn test_discriminant_send_sync() {
155 fn is_send_sync<T: Send + Sync>() {}
157 is_send_sync::<Discriminant<Regular>>();
158 is_send_sync::<Discriminant<NotSendSync>>();
162 fn assume_init_good() {
163 const TRUE: bool = unsafe { MaybeUninit::<bool>::new(true).assume_init() };
169 fn uninit_array_assume_init() {
170 let mut array = [MaybeUninit::<i16>::uninit(); 5];
177 let array = unsafe { array.transpose().assume_init() };
179 assert_eq!(array, [3, 1, 4, 1, 5]);
181 let [] = unsafe { [MaybeUninit::<!>::uninit(); 0].transpose().assume_init() };
185 fn uninit_write_slice() {
186 let mut dst = [MaybeUninit::new(255); 64];
189 assert_eq!(MaybeUninit::write_slice(&mut dst, &src), &src);
193 #[should_panic(expected = "source slice length (32) does not match destination slice length (64)")]
194 fn uninit_write_slice_panic_lt() {
195 let mut dst = [MaybeUninit::uninit(); 64];
198 MaybeUninit::write_slice(&mut dst, &src);
202 #[should_panic(expected = "source slice length (128) does not match destination slice length (64)")]
203 fn uninit_write_slice_panic_gt() {
204 let mut dst = [MaybeUninit::uninit(); 64];
207 MaybeUninit::write_slice(&mut dst, &src);
211 fn uninit_clone_from_slice() {
212 let mut dst = [MaybeUninit::new(255); 64];
215 assert_eq!(MaybeUninit::write_slice_cloned(&mut dst, &src), &src);
219 #[should_panic(expected = "destination and source slices have different lengths")]
220 fn uninit_write_slice_cloned_panic_lt() {
221 let mut dst = [MaybeUninit::uninit(); 64];
224 MaybeUninit::write_slice_cloned(&mut dst, &src);
228 #[should_panic(expected = "destination and source slices have different lengths")]
229 fn uninit_write_slice_cloned_panic_gt() {
230 let mut dst = [MaybeUninit::uninit(); 64];
233 MaybeUninit::write_slice_cloned(&mut dst, &src);
237 #[cfg(panic = "unwind")]
238 fn uninit_write_slice_cloned_mid_panic() {
241 enum IncrementOrPanic {
247 impl Clone for IncrementOrPanic {
248 fn clone(&self) -> Self {
250 Self::Increment(rc) => Self::Increment(rc.clone()),
251 Self::ExpectedPanic => panic!("expected panic on clone"),
252 Self::UnexpectedPanic => panic!("unexpected panic on clone"),
257 let rc = Rc::new(());
260 MaybeUninit::uninit(),
261 MaybeUninit::uninit(),
262 MaybeUninit::uninit(),
263 MaybeUninit::uninit(),
267 IncrementOrPanic::Increment(rc.clone()),
268 IncrementOrPanic::Increment(rc.clone()),
269 IncrementOrPanic::ExpectedPanic,
270 IncrementOrPanic::UnexpectedPanic,
273 let err = panic::catch_unwind(panic::AssertUnwindSafe(|| {
274 MaybeUninit::write_slice_cloned(&mut dst, &src);
280 Ok(_) => unreachable!(),
283 .downcast::<&'static str>()
284 .and_then(|s| if *s == "expected panic on clone" { Ok(s) } else { Err(s) })
285 .unwrap_or_else(|p| panic::resume_unwind(p));
287 assert_eq!(Rc::strong_count(&rc), 1)
293 fn uninit_write_slice_cloned_no_drop() {
299 panic!("dropped a bomb! kaboom")
303 let mut dst = [MaybeUninit::uninit()];
306 MaybeUninit::write_slice_cloned(&mut dst, &src);
312 fn uninit_const_assume_init_read() {
313 const FOO: u32 = unsafe { MaybeUninit::new(42).assume_init_read() };
318 fn const_maybe_uninit() {
321 #[derive(Debug, PartialEq)]
327 const FIELD_BY_FIELD: Foo = unsafe {
328 let mut val = MaybeUninit::uninit();
329 init_y(&mut val); // order shouldn't matter
334 const fn init_x(foo: &mut MaybeUninit<Foo>) {
336 *ptr::addr_of_mut!((*foo.as_mut_ptr()).x) = 1;
340 const fn init_y(foo: &mut MaybeUninit<Foo>) {
342 *ptr::addr_of_mut!((*foo.as_mut_ptr()).y) = 2;
346 assert_eq!(FIELD_BY_FIELD, Foo { x: 1, y: 2 });