diff --git a/tests/fail/unaligned_pointers/dyn_alignment.rs b/tests/fail/unaligned_pointers/dyn_alignment.rs index 91d9ec475b1f..39dd6f9e4c07 100644 --- a/tests/fail/unaligned_pointers/dyn_alignment.rs +++ b/tests/fail/unaligned_pointers/dyn_alignment.rs @@ -6,7 +6,8 @@ struct MuchAlign; fn main() { - for _ in 0..10 { // Try many times as this might work by chance. + for _ in 0..10 { + // Try many times as this might work by chance. let buf = [0u32; 256]; // `buf` is sufficiently aligned for `layout.align` on a `dyn Debug`, but not // for the actual alignment required by `MuchAlign`. @@ -14,7 +15,9 @@ fn main() { // as the reference is not aligned to its dynamic alignment requirements. let mut ptr = &MuchAlign as &dyn std::fmt::Debug; // Overwrite the data part of `ptr` so it points to `buf`. - unsafe { (&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8); } + unsafe { + (&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8); + } // Re-borrow that. This should be UB. let _ptr = &*ptr; //~ERROR alignment 256 is required } diff --git a/tests/fail/unaligned_pointers/reference_to_packed.rs b/tests/fail/unaligned_pointers/reference_to_packed.rs index b376859d22c1..74b2f308e230 100644 --- a/tests/fail/unaligned_pointers/reference_to_packed.rs +++ b/tests/fail/unaligned_pointers/reference_to_packed.rs @@ -10,11 +10,9 @@ struct Foo { } fn main() { - for _ in 0..10 { // Try many times as this might work by chance. - let foo = Foo { - x: 42, - y: 99, - }; + for _ in 0..10 { + // Try many times as this might work by chance. + let foo = Foo { x: 42, y: 99 }; let p = &foo.x; let i = *p; //~ERROR alignment 4 is required } diff --git a/tests/fail/unaligned_pointers/unaligned_ptr1.rs b/tests/fail/unaligned_pointers/unaligned_ptr1.rs index 1d72e5170b7c..445eb051ae2d 100644 --- a/tests/fail/unaligned_pointers/unaligned_ptr1.rs +++ b/tests/fail/unaligned_pointers/unaligned_ptr1.rs @@ -2,7 +2,8 @@ // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows fn main() { - for _ in 0..10 { // Try many times as this might work by chance. + for _ in 0..10 { + // Try many times as this might work by chance. let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error. let x = &x[0] as *const _ as *const u32; // This must fail because alignment is violated: the allocation's base is not sufficiently aligned. diff --git a/tests/fail/unaligned_pointers/unaligned_ptr3.rs b/tests/fail/unaligned_pointers/unaligned_ptr3.rs index ecab83b05a09..f13ae4888675 100644 --- a/tests/fail/unaligned_pointers/unaligned_ptr3.rs +++ b/tests/fail/unaligned_pointers/unaligned_ptr3.rs @@ -2,7 +2,8 @@ // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows fn main() { - for _ in 0..10 { // Try many times as this might work by chance. + for _ in 0..10 { + // Try many times as this might work by chance. let x = [2u16, 3, 4, 5]; // Make it big enough so we don't get an out-of-bounds error. let x = &x[0] as *const _ as *const *const u8; // cast to ptr-to-ptr, so that we load a ptr // This must fail because alignment is violated. Test specifically for loading pointers, diff --git a/tests/fail/unaligned_pointers/unaligned_ptr4.rs b/tests/fail/unaligned_pointers/unaligned_ptr4.rs index 10766746bd42..18ae48b0a1e5 100644 --- a/tests/fail/unaligned_pointers/unaligned_ptr4.rs +++ b/tests/fail/unaligned_pointers/unaligned_ptr4.rs @@ -4,7 +4,8 @@ fn main() { // Make sure we notice when a u16 is loaded at offset 1 into a u8 allocation. // (This would be missed if u8 allocations are *always* at odd addresses.) - for _ in 0..10 { // Try many times as this might work by chance. + for _ in 0..10 { + // Try many times as this might work by chance. let x = [0u8; 4]; let ptr = x.as_ptr().wrapping_offset(1).cast::(); let _val = unsafe { *ptr }; //~ERROR but alignment diff --git a/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs b/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs index e33f3c8598f3..0604a7eb2d2b 100644 --- a/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs +++ b/tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs @@ -3,7 +3,8 @@ use std::ptr; fn main() { - for _ in 0..10 { // Try many times as this might work by chance. + for _ in 0..10 { + // Try many times as this might work by chance. let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error. let x = &x[0] as *const _ as *const u32; // This must fail because alignment is violated: the allocation's base is not sufficiently aligned. diff --git a/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs b/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs index 27403c11abc7..983939688f1b 100644 --- a/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs +++ b/tests/fail/unaligned_pointers/unaligned_ptr_zst.rs @@ -3,7 +3,8 @@ // compile-flags: -Zmir-opt-level=0 -Zmiri-disable-validation fn main() { - for i in 0..10 { // Try many times as this might work by chance. + for i in 0..10 { + // Try many times as this might work by chance. let x = i as u8; let x = &x as *const _ as *const [u32; 0]; // This must fail because alignment is violated. Test specifically for loading ZST. diff --git a/tests/pass/intrinsics-integer.rs b/tests/pass/intrinsics-integer.rs index af3517af6f7a..e8a3056f2c34 100644 --- a/tests/pass/intrinsics-integer.rs +++ b/tests/pass/intrinsics-integer.rs @@ -13,110 +13,194 @@ use std::intrinsics::*; pub fn main() { unsafe { - assert_eq!(ctpop(0u8), 0); assert_eq!(ctpop(0i8), 0); - assert_eq!(ctpop(0u16), 0); assert_eq!(ctpop(0i16), 0); - assert_eq!(ctpop(0u32), 0); assert_eq!(ctpop(0i32), 0); - assert_eq!(ctpop(0u64), 0); assert_eq!(ctpop(0i64), 0); + assert_eq!(ctpop(0u8), 0); + assert_eq!(ctpop(0i8), 0); + assert_eq!(ctpop(0u16), 0); + assert_eq!(ctpop(0i16), 0); + assert_eq!(ctpop(0u32), 0); + assert_eq!(ctpop(0i32), 0); + assert_eq!(ctpop(0u64), 0); + assert_eq!(ctpop(0i64), 0); - assert_eq!(ctpop(1u8), 1); assert_eq!(ctpop(1i8), 1); - assert_eq!(ctpop(1u16), 1); assert_eq!(ctpop(1i16), 1); - assert_eq!(ctpop(1u32), 1); assert_eq!(ctpop(1i32), 1); - assert_eq!(ctpop(1u64), 1); assert_eq!(ctpop(1i64), 1); + assert_eq!(ctpop(1u8), 1); + assert_eq!(ctpop(1i8), 1); + assert_eq!(ctpop(1u16), 1); + assert_eq!(ctpop(1i16), 1); + assert_eq!(ctpop(1u32), 1); + assert_eq!(ctpop(1i32), 1); + assert_eq!(ctpop(1u64), 1); + assert_eq!(ctpop(1i64), 1); - assert_eq!(ctpop(10u8), 2); assert_eq!(ctpop(10i8), 2); - assert_eq!(ctpop(10u16), 2); assert_eq!(ctpop(10i16), 2); - assert_eq!(ctpop(10u32), 2); assert_eq!(ctpop(10i32), 2); - assert_eq!(ctpop(10u64), 2); assert_eq!(ctpop(10i64), 2); + assert_eq!(ctpop(10u8), 2); + assert_eq!(ctpop(10i8), 2); + assert_eq!(ctpop(10u16), 2); + assert_eq!(ctpop(10i16), 2); + assert_eq!(ctpop(10u32), 2); + assert_eq!(ctpop(10i32), 2); + assert_eq!(ctpop(10u64), 2); + assert_eq!(ctpop(10i64), 2); - assert_eq!(ctpop(100u8), 3); assert_eq!(ctpop(100i8), 3); - assert_eq!(ctpop(100u16), 3); assert_eq!(ctpop(100i16), 3); - assert_eq!(ctpop(100u32), 3); assert_eq!(ctpop(100i32), 3); - assert_eq!(ctpop(100u64), 3); assert_eq!(ctpop(100i64), 3); + assert_eq!(ctpop(100u8), 3); + assert_eq!(ctpop(100i8), 3); + assert_eq!(ctpop(100u16), 3); + assert_eq!(ctpop(100i16), 3); + assert_eq!(ctpop(100u32), 3); + assert_eq!(ctpop(100i32), 3); + assert_eq!(ctpop(100u64), 3); + assert_eq!(ctpop(100i64), 3); - assert_eq!(ctpop(-1i8 as u8), 8); assert_eq!(ctpop(-1i8), 8); - assert_eq!(ctpop(-1i16 as u16), 16); assert_eq!(ctpop(-1i16), 16); - assert_eq!(ctpop(-1i32 as u32), 32); assert_eq!(ctpop(-1i32), 32); - assert_eq!(ctpop(-1i64 as u64), 64); assert_eq!(ctpop(-1i64), 64); + assert_eq!(ctpop(-1i8 as u8), 8); + assert_eq!(ctpop(-1i8), 8); + assert_eq!(ctpop(-1i16 as u16), 16); + assert_eq!(ctpop(-1i16), 16); + assert_eq!(ctpop(-1i32 as u32), 32); + assert_eq!(ctpop(-1i32), 32); + assert_eq!(ctpop(-1i64 as u64), 64); + assert_eq!(ctpop(-1i64), 64); - assert_eq!(ctlz(0u8), 8); assert_eq!(ctlz(0i8), 8); - assert_eq!(ctlz(0u16), 16); assert_eq!(ctlz(0i16), 16); - assert_eq!(ctlz(0u32), 32); assert_eq!(ctlz(0i32), 32); - assert_eq!(ctlz(0u64), 64); assert_eq!(ctlz(0i64), 64); + assert_eq!(ctlz(0u8), 8); + assert_eq!(ctlz(0i8), 8); + assert_eq!(ctlz(0u16), 16); + assert_eq!(ctlz(0i16), 16); + assert_eq!(ctlz(0u32), 32); + assert_eq!(ctlz(0i32), 32); + assert_eq!(ctlz(0u64), 64); + assert_eq!(ctlz(0i64), 64); - assert_eq!(ctlz(1u8), 7); assert_eq!(ctlz(1i8), 7); - assert_eq!(ctlz(1u16), 15); assert_eq!(ctlz(1i16), 15); - assert_eq!(ctlz(1u32), 31); assert_eq!(ctlz(1i32), 31); - assert_eq!(ctlz(1u64), 63); assert_eq!(ctlz(1i64), 63); + assert_eq!(ctlz(1u8), 7); + assert_eq!(ctlz(1i8), 7); + assert_eq!(ctlz(1u16), 15); + assert_eq!(ctlz(1i16), 15); + assert_eq!(ctlz(1u32), 31); + assert_eq!(ctlz(1i32), 31); + assert_eq!(ctlz(1u64), 63); + assert_eq!(ctlz(1i64), 63); - assert_eq!(ctlz(10u8), 4); assert_eq!(ctlz(10i8), 4); - assert_eq!(ctlz(10u16), 12); assert_eq!(ctlz(10i16), 12); - assert_eq!(ctlz(10u32), 28); assert_eq!(ctlz(10i32), 28); - assert_eq!(ctlz(10u64), 60); assert_eq!(ctlz(10i64), 60); + assert_eq!(ctlz(10u8), 4); + assert_eq!(ctlz(10i8), 4); + assert_eq!(ctlz(10u16), 12); + assert_eq!(ctlz(10i16), 12); + assert_eq!(ctlz(10u32), 28); + assert_eq!(ctlz(10i32), 28); + assert_eq!(ctlz(10u64), 60); + assert_eq!(ctlz(10i64), 60); - assert_eq!(ctlz(100u8), 1); assert_eq!(ctlz(100i8), 1); - assert_eq!(ctlz(100u16), 9); assert_eq!(ctlz(100i16), 9); - assert_eq!(ctlz(100u32), 25); assert_eq!(ctlz(100i32), 25); - assert_eq!(ctlz(100u64), 57); assert_eq!(ctlz(100i64), 57); + assert_eq!(ctlz(100u8), 1); + assert_eq!(ctlz(100i8), 1); + assert_eq!(ctlz(100u16), 9); + assert_eq!(ctlz(100i16), 9); + assert_eq!(ctlz(100u32), 25); + assert_eq!(ctlz(100i32), 25); + assert_eq!(ctlz(100u64), 57); + assert_eq!(ctlz(100i64), 57); - assert_eq!(ctlz_nonzero(1u8), 7); assert_eq!(ctlz_nonzero(1i8), 7); - assert_eq!(ctlz_nonzero(1u16), 15); assert_eq!(ctlz_nonzero(1i16), 15); - assert_eq!(ctlz_nonzero(1u32), 31); assert_eq!(ctlz_nonzero(1i32), 31); - assert_eq!(ctlz_nonzero(1u64), 63); assert_eq!(ctlz_nonzero(1i64), 63); + assert_eq!(ctlz_nonzero(1u8), 7); + assert_eq!(ctlz_nonzero(1i8), 7); + assert_eq!(ctlz_nonzero(1u16), 15); + assert_eq!(ctlz_nonzero(1i16), 15); + assert_eq!(ctlz_nonzero(1u32), 31); + assert_eq!(ctlz_nonzero(1i32), 31); + assert_eq!(ctlz_nonzero(1u64), 63); + assert_eq!(ctlz_nonzero(1i64), 63); - assert_eq!(ctlz_nonzero(10u8), 4); assert_eq!(ctlz_nonzero(10i8), 4); - assert_eq!(ctlz_nonzero(10u16), 12); assert_eq!(ctlz_nonzero(10i16), 12); - assert_eq!(ctlz_nonzero(10u32), 28); assert_eq!(ctlz_nonzero(10i32), 28); - assert_eq!(ctlz_nonzero(10u64), 60); assert_eq!(ctlz_nonzero(10i64), 60); + assert_eq!(ctlz_nonzero(10u8), 4); + assert_eq!(ctlz_nonzero(10i8), 4); + assert_eq!(ctlz_nonzero(10u16), 12); + assert_eq!(ctlz_nonzero(10i16), 12); + assert_eq!(ctlz_nonzero(10u32), 28); + assert_eq!(ctlz_nonzero(10i32), 28); + assert_eq!(ctlz_nonzero(10u64), 60); + assert_eq!(ctlz_nonzero(10i64), 60); - assert_eq!(ctlz_nonzero(100u8), 1); assert_eq!(ctlz_nonzero(100i8), 1); - assert_eq!(ctlz_nonzero(100u16), 9); assert_eq!(ctlz_nonzero(100i16), 9); - assert_eq!(ctlz_nonzero(100u32), 25); assert_eq!(ctlz_nonzero(100i32), 25); - assert_eq!(ctlz_nonzero(100u64), 57); assert_eq!(ctlz_nonzero(100i64), 57); + assert_eq!(ctlz_nonzero(100u8), 1); + assert_eq!(ctlz_nonzero(100i8), 1); + assert_eq!(ctlz_nonzero(100u16), 9); + assert_eq!(ctlz_nonzero(100i16), 9); + assert_eq!(ctlz_nonzero(100u32), 25); + assert_eq!(ctlz_nonzero(100i32), 25); + assert_eq!(ctlz_nonzero(100u64), 57); + assert_eq!(ctlz_nonzero(100i64), 57); - assert_eq!(cttz(-1i8 as u8), 0); assert_eq!(cttz(-1i8), 0); - assert_eq!(cttz(-1i16 as u16), 0); assert_eq!(cttz(-1i16), 0); - assert_eq!(cttz(-1i32 as u32), 0); assert_eq!(cttz(-1i32), 0); - assert_eq!(cttz(-1i64 as u64), 0); assert_eq!(cttz(-1i64), 0); + assert_eq!(cttz(-1i8 as u8), 0); + assert_eq!(cttz(-1i8), 0); + assert_eq!(cttz(-1i16 as u16), 0); + assert_eq!(cttz(-1i16), 0); + assert_eq!(cttz(-1i32 as u32), 0); + assert_eq!(cttz(-1i32), 0); + assert_eq!(cttz(-1i64 as u64), 0); + assert_eq!(cttz(-1i64), 0); - assert_eq!(cttz(0u8), 8); assert_eq!(cttz(0i8), 8); - assert_eq!(cttz(0u16), 16); assert_eq!(cttz(0i16), 16); - assert_eq!(cttz(0u32), 32); assert_eq!(cttz(0i32), 32); - assert_eq!(cttz(0u64), 64); assert_eq!(cttz(0i64), 64); + assert_eq!(cttz(0u8), 8); + assert_eq!(cttz(0i8), 8); + assert_eq!(cttz(0u16), 16); + assert_eq!(cttz(0i16), 16); + assert_eq!(cttz(0u32), 32); + assert_eq!(cttz(0i32), 32); + assert_eq!(cttz(0u64), 64); + assert_eq!(cttz(0i64), 64); - assert_eq!(cttz(1u8), 0); assert_eq!(cttz(1i8), 0); - assert_eq!(cttz(1u16), 0); assert_eq!(cttz(1i16), 0); - assert_eq!(cttz(1u32), 0); assert_eq!(cttz(1i32), 0); - assert_eq!(cttz(1u64), 0); assert_eq!(cttz(1i64), 0); + assert_eq!(cttz(1u8), 0); + assert_eq!(cttz(1i8), 0); + assert_eq!(cttz(1u16), 0); + assert_eq!(cttz(1i16), 0); + assert_eq!(cttz(1u32), 0); + assert_eq!(cttz(1i32), 0); + assert_eq!(cttz(1u64), 0); + assert_eq!(cttz(1i64), 0); - assert_eq!(cttz(10u8), 1); assert_eq!(cttz(10i8), 1); - assert_eq!(cttz(10u16), 1); assert_eq!(cttz(10i16), 1); - assert_eq!(cttz(10u32), 1); assert_eq!(cttz(10i32), 1); - assert_eq!(cttz(10u64), 1); assert_eq!(cttz(10i64), 1); + assert_eq!(cttz(10u8), 1); + assert_eq!(cttz(10i8), 1); + assert_eq!(cttz(10u16), 1); + assert_eq!(cttz(10i16), 1); + assert_eq!(cttz(10u32), 1); + assert_eq!(cttz(10i32), 1); + assert_eq!(cttz(10u64), 1); + assert_eq!(cttz(10i64), 1); - assert_eq!(cttz(100u8), 2); assert_eq!(cttz(100i8), 2); - assert_eq!(cttz(100u16), 2); assert_eq!(cttz(100i16), 2); - assert_eq!(cttz(100u32), 2); assert_eq!(cttz(100i32), 2); - assert_eq!(cttz(100u64), 2); assert_eq!(cttz(100i64), 2); + assert_eq!(cttz(100u8), 2); + assert_eq!(cttz(100i8), 2); + assert_eq!(cttz(100u16), 2); + assert_eq!(cttz(100i16), 2); + assert_eq!(cttz(100u32), 2); + assert_eq!(cttz(100i32), 2); + assert_eq!(cttz(100u64), 2); + assert_eq!(cttz(100i64), 2); - assert_eq!(cttz_nonzero(-1i8 as u8), 0); assert_eq!(cttz_nonzero(-1i8), 0); - assert_eq!(cttz_nonzero(-1i16 as u16), 0); assert_eq!(cttz_nonzero(-1i16), 0); - assert_eq!(cttz_nonzero(-1i32 as u32), 0); assert_eq!(cttz_nonzero(-1i32), 0); - assert_eq!(cttz_nonzero(-1i64 as u64), 0); assert_eq!(cttz_nonzero(-1i64), 0); + assert_eq!(cttz_nonzero(-1i8 as u8), 0); + assert_eq!(cttz_nonzero(-1i8), 0); + assert_eq!(cttz_nonzero(-1i16 as u16), 0); + assert_eq!(cttz_nonzero(-1i16), 0); + assert_eq!(cttz_nonzero(-1i32 as u32), 0); + assert_eq!(cttz_nonzero(-1i32), 0); + assert_eq!(cttz_nonzero(-1i64 as u64), 0); + assert_eq!(cttz_nonzero(-1i64), 0); - assert_eq!(cttz_nonzero(1u8), 0); assert_eq!(cttz_nonzero(1i8), 0); - assert_eq!(cttz_nonzero(1u16), 0); assert_eq!(cttz_nonzero(1i16), 0); - assert_eq!(cttz_nonzero(1u32), 0); assert_eq!(cttz_nonzero(1i32), 0); - assert_eq!(cttz_nonzero(1u64), 0); assert_eq!(cttz_nonzero(1i64), 0); + assert_eq!(cttz_nonzero(1u8), 0); + assert_eq!(cttz_nonzero(1i8), 0); + assert_eq!(cttz_nonzero(1u16), 0); + assert_eq!(cttz_nonzero(1i16), 0); + assert_eq!(cttz_nonzero(1u32), 0); + assert_eq!(cttz_nonzero(1i32), 0); + assert_eq!(cttz_nonzero(1u64), 0); + assert_eq!(cttz_nonzero(1i64), 0); - assert_eq!(cttz_nonzero(10u8), 1); assert_eq!(cttz_nonzero(10i8), 1); - assert_eq!(cttz_nonzero(10u16), 1); assert_eq!(cttz_nonzero(10i16), 1); - assert_eq!(cttz_nonzero(10u32), 1); assert_eq!(cttz_nonzero(10i32), 1); - assert_eq!(cttz_nonzero(10u64), 1); assert_eq!(cttz_nonzero(10i64), 1); + assert_eq!(cttz_nonzero(10u8), 1); + assert_eq!(cttz_nonzero(10i8), 1); + assert_eq!(cttz_nonzero(10u16), 1); + assert_eq!(cttz_nonzero(10i16), 1); + assert_eq!(cttz_nonzero(10u32), 1); + assert_eq!(cttz_nonzero(10i32), 1); + assert_eq!(cttz_nonzero(10u64), 1); + assert_eq!(cttz_nonzero(10i64), 1); - assert_eq!(cttz_nonzero(100u8), 2); assert_eq!(cttz_nonzero(100i8), 2); - assert_eq!(cttz_nonzero(100u16), 2); assert_eq!(cttz_nonzero(100i16), 2); - assert_eq!(cttz_nonzero(100u32), 2); assert_eq!(cttz_nonzero(100i32), 2); - assert_eq!(cttz_nonzero(100u64), 2); assert_eq!(cttz_nonzero(100i64), 2); + assert_eq!(cttz_nonzero(100u8), 2); + assert_eq!(cttz_nonzero(100i8), 2); + assert_eq!(cttz_nonzero(100u16), 2); + assert_eq!(cttz_nonzero(100i16), 2); + assert_eq!(cttz_nonzero(100u32), 2); + assert_eq!(cttz_nonzero(100i32), 2); + assert_eq!(cttz_nonzero(100u64), 2); + assert_eq!(cttz_nonzero(100i64), 2); assert_eq!(bswap(0x0Au8), 0x0A); // no-op assert_eq!(bswap(0x0Ai8), 0x0A); // no-op @@ -127,20 +211,20 @@ pub fn main() { assert_eq!(bswap(0x0122334455667708u64), 0x0877665544332201); assert_eq!(bswap(0x0122334455667708i64), 0x0877665544332201); - assert_eq!(exact_div(9*9u32, 3), 27); - assert_eq!(exact_div(-9*9i32, 3), -27); - assert_eq!(exact_div(9*9i8, -3), -27); - assert_eq!(exact_div(-9*9i64, -3), 27); + assert_eq!(exact_div(9 * 9u32, 3), 27); + assert_eq!(exact_div(-9 * 9i32, 3), -27); + assert_eq!(exact_div(9 * 9i8, -3), -27); + assert_eq!(exact_div(-9 * 9i64, -3), 27); - assert_eq!(unchecked_div(9*9u32, 2), 40); - assert_eq!(unchecked_div(-9*9i32, 2), -40); - assert_eq!(unchecked_div(9*9i8, -2), -40); - assert_eq!(unchecked_div(-9*9i64, -2), 40); + assert_eq!(unchecked_div(9 * 9u32, 2), 40); + assert_eq!(unchecked_div(-9 * 9i32, 2), -40); + assert_eq!(unchecked_div(9 * 9i8, -2), -40); + assert_eq!(unchecked_div(-9 * 9i64, -2), 40); - assert_eq!(unchecked_rem(9*9u32, 2), 1); - assert_eq!(unchecked_rem(-9*9i32, 2), -1); - assert_eq!(unchecked_rem(9*9i8, -2), 1); - assert_eq!(unchecked_rem(-9*9i64, -2), -1); + assert_eq!(unchecked_rem(9 * 9u32, 2), 1); + assert_eq!(unchecked_rem(-9 * 9i32, 2), -1); + assert_eq!(unchecked_rem(9 * 9i8, -2), 1); + assert_eq!(unchecked_rem(-9 * 9i64, -2), -1); assert_eq!(unchecked_add(23u8, 19), 42); assert_eq!(unchecked_add(5, -10), -5); diff --git a/tests/pass/panic/catch_panic.rs b/tests/pass/panic/catch_panic.rs index 80881948c03c..2fb00391cd79 100644 --- a/tests/pass/panic/catch_panic.rs +++ b/tests/pass/panic/catch_panic.rs @@ -3,8 +3,8 @@ #![feature(never_type)] #![allow(unconditional_panic, non_fmt_panics)] -use std::panic::{catch_unwind, AssertUnwindSafe}; use std::cell::Cell; +use std::panic::{catch_unwind, AssertUnwindSafe}; thread_local! { static MY_COUNTER: Cell = Cell::new(0); @@ -59,23 +59,29 @@ fn main() { test(None, |old_val| core::panic!("Hello from panic: {:?}", old_val)); // Built-in panics; also make sure the message is right. - test( - Some("index out of bounds: the len is 3 but the index is 4"), - |_old_val| { let _val = [0, 1, 2][4]; loop {} }, - ); - test( - Some("attempt to divide by zero"), - |_old_val| { let _val = 1/0; loop {} }, - ); + test(Some("index out of bounds: the len is 3 but the index is 4"), |_old_val| { + let _val = [0, 1, 2][4]; + loop {} + }); + test(Some("attempt to divide by zero"), |_old_val| { + let _val = 1 / 0; + loop {} + }); - test( - Some("align_offset: align is not a power-of-two"), - |_old_val| { (0usize as *const u8).align_offset(3); loop {} }, - ); + test(Some("align_offset: align is not a power-of-two"), |_old_val| { + (0usize as *const u8).align_offset(3); + loop {} + }); // Assertion and debug assertion - test(None, |_old_val| { assert!(false); loop {} }); - test(None, |_old_val| { debug_assert!(false); loop {} }); + test(None, |_old_val| { + assert!(false); + loop {} + }); + test(None, |_old_val| { + debug_assert!(false); + loop {} + }); eprintln!("Success!"); // Make sure we get this in stderr } @@ -89,7 +95,8 @@ fn test(expect_msg: Option<&str>, do_panic: impl FnOnce(usize) -> !) { let res = catch_unwind(AssertUnwindSafe(|| { let _string = "LEAKED FROM CLOSURE".to_string(); do_panic_counter(do_panic) - })).expect_err("do_panic() did not panic!"); + })) + .expect_err("do_panic() did not panic!"); // See if we can extract the panic message. let msg = if let Some(s) = res.downcast_ref::() { diff --git a/tests/pass/ptr_int_casts.rs b/tests/pass/ptr_int_casts.rs index b9815126a8c7..aa60fd0c81ef 100644 --- a/tests/pass/ptr_int_casts.rs +++ b/tests/pass/ptr_int_casts.rs @@ -5,12 +5,14 @@ fn eq_ref(x: &T, y: &T) -> bool { x as *const _ == y as *const _ } -fn f() -> i32 { 42 } +fn f() -> i32 { + 42 +} fn ptr_int_casts() { // int-ptr-int assert_eq!(1 as *const i32 as usize, 1); - assert_eq!((1 as *const i32).wrapping_offset(4) as usize, 1 + 4*4); + assert_eq!((1 as *const i32).wrapping_offset(4) as usize, 1 + 4 * 4); // negative overflowing wrapping_offset (going through memory because // this used to trigger an ICE on 32bit) @@ -18,7 +20,8 @@ fn ptr_int_casts() { *val = (1 as *const u8).wrapping_offset(-4); assert_eq!(*val as usize, usize::MAX - 2); - { // ptr-int-ptr + { + // ptr-int-ptr let x = 13; let mut y = &x as &_ as *const _ as usize; y += 13; @@ -27,13 +30,14 @@ fn ptr_int_casts() { assert!(eq_ref(&x, unsafe { &*y })); } - { // fnptr-int-fnptr - let x : fn() -> i32 = f; - let y : *mut u8 = unsafe { mem::transmute(x as fn() -> i32) }; + { + // fnptr-int-fnptr + let x: fn() -> i32 = f; + let y: *mut u8 = unsafe { mem::transmute(x as fn() -> i32) }; let mut y = y as usize; y += 13; y -= 13; - let x : fn() -> i32 = unsafe { mem::transmute(y as *mut u8) }; + let x: fn() -> i32 = unsafe { mem::transmute(y as *mut u8) }; assert_eq!(x(), 42); } @@ -51,13 +55,13 @@ fn ptr_int_ops() { // bit-operations, covered by alignment assert_eq!(x & 1, 0); assert_eq!(x & 0, 0); - assert_eq!(1 & (x+1), 1); + assert_eq!(1 & (x + 1), 1); let _y = !1 & x; let _y = !0 & x; let _y = x & !1; // remainder, covered by alignment assert_eq!(x % 2, 0); - assert_eq!((x+1) % 2, 1); + assert_eq!((x + 1) % 2, 1); // remainder with 1 is always 0 assert_eq!(x % 1, 0); } diff --git a/tests/pass/regions-lifetime-nonfree-late-bound.rs b/tests/pass/regions-lifetime-nonfree-late-bound.rs index 78aeea64814a..c91ac36ed6b4 100644 --- a/tests/pass/regions-lifetime-nonfree-late-bound.rs +++ b/tests/pass/regions-lifetime-nonfree-late-bound.rs @@ -16,15 +16,23 @@ pub fn main() { fn explicit() { - fn test(_x: Option>) where F: FnMut(Box FnMut(&'a isize)>) {} + fn test(_x: Option>) + where + F: FnMut(Box FnMut(&'a isize)>), + { + } test(Some(box |_f: Box FnMut(&'a isize)>| {})); } // The code below is shorthand for the code above (and more likely // to represent what one encounters in practice). fn implicit() { - fn test(_x: Option>) where F: FnMut(Box) {} - test(Some(box |_f: Box| {})); + fn test(_x: Option>) + where + F: FnMut(Box), + { + } + test(Some(box |_f: Box| {})); } explicit(); diff --git a/tests/pass/sums.rs b/tests/pass/sums.rs index daeba060a78b..84ff96942002 100644 --- a/tests/pass/sums.rs +++ b/tests/pass/sums.rs @@ -1,12 +1,17 @@ #[derive(Debug, PartialEq)] -enum Unit { Unit(()) } // Force non-C-enum representation. +enum Unit { + Unit(()), +} // Force non-C-enum representation. fn return_unit() -> Unit { Unit::Unit(()) } #[derive(Debug, PartialEq)] -enum MyBool { False(()), True(()) } // Force non-C-enum representation. +enum MyBool { + False(()), + True(()), +} // Force non-C-enum representation. fn return_true() -> MyBool { MyBool::True(())