Skip to content

Commit 3d1d345

Browse files
borsbors
committed
Auto merge of rust-lang#2255 - dtolnay-contrib:rustfmt7, r=oli-obk
Format tests with rustfmt (288-299 of 299) Extracted from rust-lang#2097. I'll make a separate PR to enable checking the `tests` directory's formatting in CI. I'll need to rebase that after both this and rust-lang#2254 have landed, and if any new non-rustfmt-formatted files appear in the meantime, we can include formatting those in the same PR that enables the CI.
2 parents f664196 + 274085c commit 3d1d345

12 files changed

+190
-159
lines changed

‎tests/fail/unaligned_pointers/dyn_alignment.rs

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,15 +6,18 @@
66
struct MuchAlign;
77

88
fn main() {
9-
for _ in 0..10 { // Try many times as this might work by chance.
9+
// Try many times as this might work by chance.
10+
for _ in 0..10 {
1011
let buf = [0u32; 256];
1112
// `buf` is sufficiently aligned for `layout.align` on a `dyn Debug`, but not
1213
// for the actual alignment required by `MuchAlign`.
1314
// We craft a wide reference `&dyn Debug` with the vtable for `MuchAlign`. That should be UB,
1415
// as the reference is not aligned to its dynamic alignment requirements.
1516
let mut ptr = &MuchAlign as &dyn std::fmt::Debug;
1617
// Overwrite the data part of `ptr` so it points to `buf`.
17-
unsafe { (&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8); }
18+
unsafe {
19+
(&mut ptr as *mut _ as *mut *const u8).write(&buf as *const _ as *const u8);
20+
}
1821
// Re-borrow that. This should be UB.
1922
let _ptr = &*ptr; //~ERROR alignment 256 is required
2023
}

‎tests/fail/unaligned_pointers/reference_to_packed.rs

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,9 @@ struct Foo {
1010
}
1111

1212
fn main() {
13-
for _ in 0..10 { // Try many times as this might work by chance.
14-
let foo = Foo {
15-
x: 42,
16-
y: 99,
17-
};
13+
// Try many times as this might work by chance.
14+
for _ in 0..10 {
15+
let foo = Foo { x: 42, y: 99 };
1816
let p = &foo.x;
1917
let i = *p; //~ERROR alignment 4 is required
2018
}

‎tests/fail/unaligned_pointers/unaligned_ptr1.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@
22
// compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
33

44
fn main() {
5-
for _ in 0..10 { // Try many times as this might work by chance.
5+
// Try many times as this might work by chance.
6+
for _ in 0..10 {
67
let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
78
let x = &x[0] as *const _ as *const u32;
89
// This must fail because alignment is violated: the allocation's base is not sufficiently aligned.

‎tests/fail/unaligned_pointers/unaligned_ptr3.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@
22
// compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
33

44
fn main() {
5-
for _ in 0..10 { // Try many times as this might work by chance.
5+
// Try many times as this might work by chance.
6+
for _ in 0..10 {
67
let x = [2u16, 3, 4, 5]; // Make it big enough so we don't get an out-of-bounds error.
78
let x = &x[0] as *const _ as *const *const u8; // cast to ptr-to-ptr, so that we load a ptr
89
// This must fail because alignment is violated. Test specifically for loading pointers,

‎tests/fail/unaligned_pointers/unaligned_ptr4.rs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,9 @@
44
fn main() {
55
// Make sure we notice when a u16 is loaded at offset 1 into a u8 allocation.
66
// (This would be missed if u8 allocations are *always* at odd addresses.)
7-
for _ in 0..10 { // Try many times as this might work by chance.
7+
//
8+
// Try many times as this might work by chance.
9+
for _ in 0..10 {
810
let x = [0u8; 4];
911
let ptr = x.as_ptr().wrapping_offset(1).cast::<u16>();
1012
let _val = unsafe { *ptr }; //~ERROR but alignment

‎tests/fail/unaligned_pointers/unaligned_ptr_addr_of.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@
33
use std::ptr;
44

55
fn main() {
6-
for _ in 0..10 { // Try many times as this might work by chance.
6+
// Try many times as this might work by chance.
7+
for _ in 0..10 {
78
let x = [2u16, 3, 4]; // Make it big enough so we don't get an out-of-bounds error.
89
let x = &x[0] as *const _ as *const u32;
910
// This must fail because alignment is violated: the allocation's base is not sufficiently aligned.

‎tests/fail/unaligned_pointers/unaligned_ptr_zst.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@
33
// compile-flags: -Zmir-opt-level=0 -Zmiri-disable-validation
44

55
fn main() {
6-
for i in 0..10 { // Try many times as this might work by chance.
6+
// Try many times as this might work by chance.
7+
for i in 0..10 {
78
let x = i as u8;
89
let x = &x as *const _ as *const [u32; 0];
910
// This must fail because alignment is violated. Test specifically for loading ZST.

‎tests/pass/intrinsics-integer.rs

Lines changed: 116 additions & 116 deletions
Original file line numberDiff line numberDiff line change
@@ -13,110 +13,110 @@ use std::intrinsics::*;
1313

1414
pub fn main() {
1515
unsafe {
16-
assert_eq!(ctpop(0u8), 0); assert_eq!(ctpop(0i8), 0);
17-
assert_eq!(ctpop(0u16), 0); assert_eq!(ctpop(0i16), 0);
18-
assert_eq!(ctpop(0u32), 0); assert_eq!(ctpop(0i32), 0);
19-
assert_eq!(ctpop(0u64), 0); assert_eq!(ctpop(0i64), 0);
20-
21-
assert_eq!(ctpop(1u8), 1); assert_eq!(ctpop(1i8), 1);
22-
assert_eq!(ctpop(1u16), 1); assert_eq!(ctpop(1i16), 1);
23-
assert_eq!(ctpop(1u32), 1); assert_eq!(ctpop(1i32), 1);
24-
assert_eq!(ctpop(1u64), 1); assert_eq!(ctpop(1i64), 1);
25-
26-
assert_eq!(ctpop(10u8), 2); assert_eq!(ctpop(10i8), 2);
27-
assert_eq!(ctpop(10u16), 2); assert_eq!(ctpop(10i16), 2);
28-
assert_eq!(ctpop(10u32), 2); assert_eq!(ctpop(10i32), 2);
29-
assert_eq!(ctpop(10u64), 2); assert_eq!(ctpop(10i64), 2);
30-
31-
assert_eq!(ctpop(100u8), 3); assert_eq!(ctpop(100i8), 3);
32-
assert_eq!(ctpop(100u16), 3); assert_eq!(ctpop(100i16), 3);
33-
assert_eq!(ctpop(100u32), 3); assert_eq!(ctpop(100i32), 3);
34-
assert_eq!(ctpop(100u64), 3); assert_eq!(ctpop(100i64), 3);
35-
36-
assert_eq!(ctpop(-1i8 as u8), 8); assert_eq!(ctpop(-1i8), 8);
37-
assert_eq!(ctpop(-1i16 as u16), 16); assert_eq!(ctpop(-1i16), 16);
38-
assert_eq!(ctpop(-1i32 as u32), 32); assert_eq!(ctpop(-1i32), 32);
39-
assert_eq!(ctpop(-1i64 as u64), 64); assert_eq!(ctpop(-1i64), 64);
40-
41-
assert_eq!(ctlz(0u8), 8); assert_eq!(ctlz(0i8), 8);
42-
assert_eq!(ctlz(0u16), 16); assert_eq!(ctlz(0i16), 16);
43-
assert_eq!(ctlz(0u32), 32); assert_eq!(ctlz(0i32), 32);
44-
assert_eq!(ctlz(0u64), 64); assert_eq!(ctlz(0i64), 64);
45-
46-
assert_eq!(ctlz(1u8), 7); assert_eq!(ctlz(1i8), 7);
47-
assert_eq!(ctlz(1u16), 15); assert_eq!(ctlz(1i16), 15);
48-
assert_eq!(ctlz(1u32), 31); assert_eq!(ctlz(1i32), 31);
49-
assert_eq!(ctlz(1u64), 63); assert_eq!(ctlz(1i64), 63);
50-
51-
assert_eq!(ctlz(10u8), 4); assert_eq!(ctlz(10i8), 4);
52-
assert_eq!(ctlz(10u16), 12); assert_eq!(ctlz(10i16), 12);
53-
assert_eq!(ctlz(10u32), 28); assert_eq!(ctlz(10i32), 28);
54-
assert_eq!(ctlz(10u64), 60); assert_eq!(ctlz(10i64), 60);
55-
56-
assert_eq!(ctlz(100u8), 1); assert_eq!(ctlz(100i8), 1);
57-
assert_eq!(ctlz(100u16), 9); assert_eq!(ctlz(100i16), 9);
58-
assert_eq!(ctlz(100u32), 25); assert_eq!(ctlz(100i32), 25);
59-
assert_eq!(ctlz(100u64), 57); assert_eq!(ctlz(100i64), 57);
60-
61-
assert_eq!(ctlz_nonzero(1u8), 7); assert_eq!(ctlz_nonzero(1i8), 7);
62-
assert_eq!(ctlz_nonzero(1u16), 15); assert_eq!(ctlz_nonzero(1i16), 15);
63-
assert_eq!(ctlz_nonzero(1u32), 31); assert_eq!(ctlz_nonzero(1i32), 31);
64-
assert_eq!(ctlz_nonzero(1u64), 63); assert_eq!(ctlz_nonzero(1i64), 63);
65-
66-
assert_eq!(ctlz_nonzero(10u8), 4); assert_eq!(ctlz_nonzero(10i8), 4);
67-
assert_eq!(ctlz_nonzero(10u16), 12); assert_eq!(ctlz_nonzero(10i16), 12);
68-
assert_eq!(ctlz_nonzero(10u32), 28); assert_eq!(ctlz_nonzero(10i32), 28);
69-
assert_eq!(ctlz_nonzero(10u64), 60); assert_eq!(ctlz_nonzero(10i64), 60);
70-
71-
assert_eq!(ctlz_nonzero(100u8), 1); assert_eq!(ctlz_nonzero(100i8), 1);
72-
assert_eq!(ctlz_nonzero(100u16), 9); assert_eq!(ctlz_nonzero(100i16), 9);
73-
assert_eq!(ctlz_nonzero(100u32), 25); assert_eq!(ctlz_nonzero(100i32), 25);
74-
assert_eq!(ctlz_nonzero(100u64), 57); assert_eq!(ctlz_nonzero(100i64), 57);
75-
76-
assert_eq!(cttz(-1i8 as u8), 0); assert_eq!(cttz(-1i8), 0);
77-
assert_eq!(cttz(-1i16 as u16), 0); assert_eq!(cttz(-1i16), 0);
78-
assert_eq!(cttz(-1i32 as u32), 0); assert_eq!(cttz(-1i32), 0);
79-
assert_eq!(cttz(-1i64 as u64), 0); assert_eq!(cttz(-1i64), 0);
80-
81-
assert_eq!(cttz(0u8), 8); assert_eq!(cttz(0i8), 8);
82-
assert_eq!(cttz(0u16), 16); assert_eq!(cttz(0i16), 16);
83-
assert_eq!(cttz(0u32), 32); assert_eq!(cttz(0i32), 32);
84-
assert_eq!(cttz(0u64), 64); assert_eq!(cttz(0i64), 64);
85-
86-
assert_eq!(cttz(1u8), 0); assert_eq!(cttz(1i8), 0);
87-
assert_eq!(cttz(1u16), 0); assert_eq!(cttz(1i16), 0);
88-
assert_eq!(cttz(1u32), 0); assert_eq!(cttz(1i32), 0);
89-
assert_eq!(cttz(1u64), 0); assert_eq!(cttz(1i64), 0);
90-
91-
assert_eq!(cttz(10u8), 1); assert_eq!(cttz(10i8), 1);
92-
assert_eq!(cttz(10u16), 1); assert_eq!(cttz(10i16), 1);
93-
assert_eq!(cttz(10u32), 1); assert_eq!(cttz(10i32), 1);
94-
assert_eq!(cttz(10u64), 1); assert_eq!(cttz(10i64), 1);
95-
96-
assert_eq!(cttz(100u8), 2); assert_eq!(cttz(100i8), 2);
97-
assert_eq!(cttz(100u16), 2); assert_eq!(cttz(100i16), 2);
98-
assert_eq!(cttz(100u32), 2); assert_eq!(cttz(100i32), 2);
99-
assert_eq!(cttz(100u64), 2); assert_eq!(cttz(100i64), 2);
100-
101-
assert_eq!(cttz_nonzero(-1i8 as u8), 0); assert_eq!(cttz_nonzero(-1i8), 0);
102-
assert_eq!(cttz_nonzero(-1i16 as u16), 0); assert_eq!(cttz_nonzero(-1i16), 0);
103-
assert_eq!(cttz_nonzero(-1i32 as u32), 0); assert_eq!(cttz_nonzero(-1i32), 0);
104-
assert_eq!(cttz_nonzero(-1i64 as u64), 0); assert_eq!(cttz_nonzero(-1i64), 0);
105-
106-
assert_eq!(cttz_nonzero(1u8), 0); assert_eq!(cttz_nonzero(1i8), 0);
107-
assert_eq!(cttz_nonzero(1u16), 0); assert_eq!(cttz_nonzero(1i16), 0);
108-
assert_eq!(cttz_nonzero(1u32), 0); assert_eq!(cttz_nonzero(1i32), 0);
109-
assert_eq!(cttz_nonzero(1u64), 0); assert_eq!(cttz_nonzero(1i64), 0);
110-
111-
assert_eq!(cttz_nonzero(10u8), 1); assert_eq!(cttz_nonzero(10i8), 1);
112-
assert_eq!(cttz_nonzero(10u16), 1); assert_eq!(cttz_nonzero(10i16), 1);
113-
assert_eq!(cttz_nonzero(10u32), 1); assert_eq!(cttz_nonzero(10i32), 1);
114-
assert_eq!(cttz_nonzero(10u64), 1); assert_eq!(cttz_nonzero(10i64), 1);
115-
116-
assert_eq!(cttz_nonzero(100u8), 2); assert_eq!(cttz_nonzero(100i8), 2);
117-
assert_eq!(cttz_nonzero(100u16), 2); assert_eq!(cttz_nonzero(100i16), 2);
118-
assert_eq!(cttz_nonzero(100u32), 2); assert_eq!(cttz_nonzero(100i32), 2);
119-
assert_eq!(cttz_nonzero(100u64), 2); assert_eq!(cttz_nonzero(100i64), 2);
16+
[assert_eq!(ctpop(0u8), 0), assert_eq!(ctpop(0i8), 0)];
17+
[assert_eq!(ctpop(0u16), 0), assert_eq!(ctpop(0i16), 0)];
18+
[assert_eq!(ctpop(0u32), 0), assert_eq!(ctpop(0i32), 0)];
19+
[assert_eq!(ctpop(0u64), 0), assert_eq!(ctpop(0i64), 0)];
20+
21+
[assert_eq!(ctpop(1u8), 1), assert_eq!(ctpop(1i8), 1)];
22+
[assert_eq!(ctpop(1u16), 1), assert_eq!(ctpop(1i16), 1)];
23+
[assert_eq!(ctpop(1u32), 1), assert_eq!(ctpop(1i32), 1)];
24+
[assert_eq!(ctpop(1u64), 1), assert_eq!(ctpop(1i64), 1)];
25+
26+
[assert_eq!(ctpop(10u8), 2), assert_eq!(ctpop(10i8), 2)];
27+
[assert_eq!(ctpop(10u16), 2), assert_eq!(ctpop(10i16), 2)];
28+
[assert_eq!(ctpop(10u32), 2), assert_eq!(ctpop(10i32), 2)];
29+
[assert_eq!(ctpop(10u64), 2), assert_eq!(ctpop(10i64), 2)];
30+
31+
[assert_eq!(ctpop(100u8), 3), assert_eq!(ctpop(100i8), 3)];
32+
[assert_eq!(ctpop(100u16), 3), assert_eq!(ctpop(100i16), 3)];
33+
[assert_eq!(ctpop(100u32), 3), assert_eq!(ctpop(100i32), 3)];
34+
[assert_eq!(ctpop(100u64), 3), assert_eq!(ctpop(100i64), 3)];
35+
36+
[assert_eq!(ctpop(-1i8 as u8), 8), assert_eq!(ctpop(-1i8), 8)];
37+
[assert_eq!(ctpop(-1i16 as u16), 16), assert_eq!(ctpop(-1i16), 16)];
38+
[assert_eq!(ctpop(-1i32 as u32), 32), assert_eq!(ctpop(-1i32), 32)];
39+
[assert_eq!(ctpop(-1i64 as u64), 64), assert_eq!(ctpop(-1i64), 64)];
40+
41+
[assert_eq!(ctlz(0u8), 8), assert_eq!(ctlz(0i8), 8)];
42+
[assert_eq!(ctlz(0u16), 16), assert_eq!(ctlz(0i16), 16)];
43+
[assert_eq!(ctlz(0u32), 32), assert_eq!(ctlz(0i32), 32)];
44+
[assert_eq!(ctlz(0u64), 64), assert_eq!(ctlz(0i64), 64)];
45+
46+
[assert_eq!(ctlz(1u8), 7), assert_eq!(ctlz(1i8), 7)];
47+
[assert_eq!(ctlz(1u16), 15), assert_eq!(ctlz(1i16), 15)];
48+
[assert_eq!(ctlz(1u32), 31), assert_eq!(ctlz(1i32), 31)];
49+
[assert_eq!(ctlz(1u64), 63), assert_eq!(ctlz(1i64), 63)];
50+
51+
[assert_eq!(ctlz(10u8), 4), assert_eq!(ctlz(10i8), 4)];
52+
[assert_eq!(ctlz(10u16), 12), assert_eq!(ctlz(10i16), 12)];
53+
[assert_eq!(ctlz(10u32), 28), assert_eq!(ctlz(10i32), 28)];
54+
[assert_eq!(ctlz(10u64), 60), assert_eq!(ctlz(10i64), 60)];
55+
56+
[assert_eq!(ctlz(100u8), 1), assert_eq!(ctlz(100i8), 1)];
57+
[assert_eq!(ctlz(100u16), 9), assert_eq!(ctlz(100i16), 9)];
58+
[assert_eq!(ctlz(100u32), 25), assert_eq!(ctlz(100i32), 25)];
59+
[assert_eq!(ctlz(100u64), 57), assert_eq!(ctlz(100i64), 57)];
60+
61+
[assert_eq!(ctlz_nonzero(1u8), 7), assert_eq!(ctlz_nonzero(1i8), 7)];
62+
[assert_eq!(ctlz_nonzero(1u16), 15), assert_eq!(ctlz_nonzero(1i16), 15)];
63+
[assert_eq!(ctlz_nonzero(1u32), 31), assert_eq!(ctlz_nonzero(1i32), 31)];
64+
[assert_eq!(ctlz_nonzero(1u64), 63), assert_eq!(ctlz_nonzero(1i64), 63)];
65+
66+
[assert_eq!(ctlz_nonzero(10u8), 4), assert_eq!(ctlz_nonzero(10i8), 4)];
67+
[assert_eq!(ctlz_nonzero(10u16), 12), assert_eq!(ctlz_nonzero(10i16), 12)];
68+
[assert_eq!(ctlz_nonzero(10u32), 28), assert_eq!(ctlz_nonzero(10i32), 28)];
69+
[assert_eq!(ctlz_nonzero(10u64), 60), assert_eq!(ctlz_nonzero(10i64), 60)];
70+
71+
[assert_eq!(ctlz_nonzero(100u8), 1), assert_eq!(ctlz_nonzero(100i8), 1)];
72+
[assert_eq!(ctlz_nonzero(100u16), 9), assert_eq!(ctlz_nonzero(100i16), 9)];
73+
[assert_eq!(ctlz_nonzero(100u32), 25), assert_eq!(ctlz_nonzero(100i32), 25)];
74+
[assert_eq!(ctlz_nonzero(100u64), 57), assert_eq!(ctlz_nonzero(100i64), 57)];
75+
76+
[assert_eq!(cttz(-1i8 as u8), 0), assert_eq!(cttz(-1i8), 0)];
77+
[assert_eq!(cttz(-1i16 as u16), 0), assert_eq!(cttz(-1i16), 0)];
78+
[assert_eq!(cttz(-1i32 as u32), 0), assert_eq!(cttz(-1i32), 0)];
79+
[assert_eq!(cttz(-1i64 as u64), 0), assert_eq!(cttz(-1i64), 0)];
80+
81+
[assert_eq!(cttz(0u8), 8), assert_eq!(cttz(0i8), 8)];
82+
[assert_eq!(cttz(0u16), 16), assert_eq!(cttz(0i16), 16)];
83+
[assert_eq!(cttz(0u32), 32), assert_eq!(cttz(0i32), 32)];
84+
[assert_eq!(cttz(0u64), 64), assert_eq!(cttz(0i64), 64)];
85+
86+
[assert_eq!(cttz(1u8), 0), assert_eq!(cttz(1i8), 0)];
87+
[assert_eq!(cttz(1u16), 0), assert_eq!(cttz(1i16), 0)];
88+
[assert_eq!(cttz(1u32), 0), assert_eq!(cttz(1i32), 0)];
89+
[assert_eq!(cttz(1u64), 0), assert_eq!(cttz(1i64), 0)];
90+
91+
[assert_eq!(cttz(10u8), 1), assert_eq!(cttz(10i8), 1)];
92+
[assert_eq!(cttz(10u16), 1), assert_eq!(cttz(10i16), 1)];
93+
[assert_eq!(cttz(10u32), 1), assert_eq!(cttz(10i32), 1)];
94+
[assert_eq!(cttz(10u64), 1), assert_eq!(cttz(10i64), 1)];
95+
96+
[assert_eq!(cttz(100u8), 2), assert_eq!(cttz(100i8), 2)];
97+
[assert_eq!(cttz(100u16), 2), assert_eq!(cttz(100i16), 2)];
98+
[assert_eq!(cttz(100u32), 2), assert_eq!(cttz(100i32), 2)];
99+
[assert_eq!(cttz(100u64), 2), assert_eq!(cttz(100i64), 2)];
100+
101+
[assert_eq!(cttz_nonzero(-1i8 as u8), 0), assert_eq!(cttz_nonzero(-1i8), 0)];
102+
[assert_eq!(cttz_nonzero(-1i16 as u16), 0), assert_eq!(cttz_nonzero(-1i16), 0)];
103+
[assert_eq!(cttz_nonzero(-1i32 as u32), 0), assert_eq!(cttz_nonzero(-1i32), 0)];
104+
[assert_eq!(cttz_nonzero(-1i64 as u64), 0), assert_eq!(cttz_nonzero(-1i64), 0)];
105+
106+
[assert_eq!(cttz_nonzero(1u8), 0), assert_eq!(cttz_nonzero(1i8), 0)];
107+
[assert_eq!(cttz_nonzero(1u16), 0), assert_eq!(cttz_nonzero(1i16), 0)];
108+
[assert_eq!(cttz_nonzero(1u32), 0), assert_eq!(cttz_nonzero(1i32), 0)];
109+
[assert_eq!(cttz_nonzero(1u64), 0), assert_eq!(cttz_nonzero(1i64), 0)];
110+
111+
[assert_eq!(cttz_nonzero(10u8), 1), assert_eq!(cttz_nonzero(10i8), 1)];
112+
[assert_eq!(cttz_nonzero(10u16), 1), assert_eq!(cttz_nonzero(10i16), 1)];
113+
[assert_eq!(cttz_nonzero(10u32), 1), assert_eq!(cttz_nonzero(10i32), 1)];
114+
[assert_eq!(cttz_nonzero(10u64), 1), assert_eq!(cttz_nonzero(10i64), 1)];
115+
116+
[assert_eq!(cttz_nonzero(100u8), 2), assert_eq!(cttz_nonzero(100i8), 2)];
117+
[assert_eq!(cttz_nonzero(100u16), 2), assert_eq!(cttz_nonzero(100i16), 2)];
118+
[assert_eq!(cttz_nonzero(100u32), 2), assert_eq!(cttz_nonzero(100i32), 2)];
119+
[assert_eq!(cttz_nonzero(100u64), 2), assert_eq!(cttz_nonzero(100i64), 2)];
120120

121121
assert_eq!(bswap(0x0Au8), 0x0A); // no-op
122122
assert_eq!(bswap(0x0Ai8), 0x0A); // no-op
@@ -127,20 +127,20 @@ pub fn main() {
127127
assert_eq!(bswap(0x0122334455667708u64), 0x0877665544332201);
128128
assert_eq!(bswap(0x0122334455667708i64), 0x0877665544332201);
129129

130-
assert_eq!(exact_div(9*9u32, 3), 27);
131-
assert_eq!(exact_div(-9*9i32, 3), -27);
132-
assert_eq!(exact_div(9*9i8, -3), -27);
133-
assert_eq!(exact_div(-9*9i64, -3), 27);
130+
assert_eq!(exact_div(9 * 9u32, 3), 27);
131+
assert_eq!(exact_div(-9 * 9i32, 3), -27);
132+
assert_eq!(exact_div(9 * 9i8, -3), -27);
133+
assert_eq!(exact_div(-9 * 9i64, -3), 27);
134134

135-
assert_eq!(unchecked_div(9*9u32, 2), 40);
136-
assert_eq!(unchecked_div(-9*9i32, 2), -40);
137-
assert_eq!(unchecked_div(9*9i8, -2), -40);
138-
assert_eq!(unchecked_div(-9*9i64, -2), 40);
135+
assert_eq!(unchecked_div(9 * 9u32, 2), 40);
136+
assert_eq!(unchecked_div(-9 * 9i32, 2), -40);
137+
assert_eq!(unchecked_div(9 * 9i8, -2), -40);
138+
assert_eq!(unchecked_div(-9 * 9i64, -2), 40);
139139

140-
assert_eq!(unchecked_rem(9*9u32, 2), 1);
141-
assert_eq!(unchecked_rem(-9*9i32, 2), -1);
142-
assert_eq!(unchecked_rem(9*9i8, -2), 1);
143-
assert_eq!(unchecked_rem(-9*9i64, -2), -1);
140+
assert_eq!(unchecked_rem(9 * 9u32, 2), 1);
141+
assert_eq!(unchecked_rem(-9 * 9i32, 2), -1);
142+
assert_eq!(unchecked_rem(9 * 9i8, -2), 1);
143+
assert_eq!(unchecked_rem(-9 * 9i64, -2), -1);
144144

145145
assert_eq!(unchecked_add(23u8, 19), 42);
146146
assert_eq!(unchecked_add(5, -10), -5);

‎tests/pass/panic/catch_panic.rs

Lines changed: 24 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -3,8 +3,8 @@
33
#![feature(never_type)]
44
#![allow(unconditional_panic, non_fmt_panics)]
55

6-
use std::panic::{catch_unwind, AssertUnwindSafe};
76
use std::cell::Cell;
7+
use std::panic::{catch_unwind, AssertUnwindSafe};
88

99
thread_local! {
1010
static MY_COUNTER: Cell<usize> = Cell::new(0);
@@ -59,23 +59,29 @@ fn main() {
5959
test(None, |old_val| core::panic!("Hello from panic: {:?}", old_val));
6060

6161
// Built-in panics; also make sure the message is right.
62-
test(
63-
Some("index out of bounds: the len is 3 but the index is 4"),
64-
|_old_val| { let _val = [0, 1, 2][4]; loop {} },
65-
);
66-
test(
67-
Some("attempt to divide by zero"),
68-
|_old_val| { let _val = 1/0; loop {} },
69-
);
70-
71-
test(
72-
Some("align_offset: align is not a power-of-two"),
73-
|_old_val| { (0usize as *const u8).align_offset(3); loop {} },
74-
);
62+
test(Some("index out of bounds: the len is 3 but the index is 4"), |_old_val| {
63+
let _val = [0, 1, 2][4];
64+
loop {}
65+
});
66+
test(Some("attempt to divide by zero"), |_old_val| {
67+
let _val = 1 / 0;
68+
loop {}
69+
});
70+
71+
test(Some("align_offset: align is not a power-of-two"), |_old_val| {
72+
(0usize as *const u8).align_offset(3);
73+
loop {}
74+
});
7575

7676
// Assertion and debug assertion
77-
test(None, |_old_val| { assert!(false); loop {} });
78-
test(None, |_old_val| { debug_assert!(false); loop {} });
77+
test(None, |_old_val| {
78+
assert!(false);
79+
loop {}
80+
});
81+
test(None, |_old_val| {
82+
debug_assert!(false);
83+
loop {}
84+
});
7985

8086
eprintln!("Success!"); // Make sure we get this in stderr
8187
}
@@ -89,7 +95,8 @@ fn test(expect_msg: Option<&str>, do_panic: impl FnOnce(usize) -> !) {
8995
let res = catch_unwind(AssertUnwindSafe(|| {
9096
let _string = "LEAKED FROM CLOSURE".to_string();
9197
do_panic_counter(do_panic)
92-
})).expect_err("do_panic() did not panic!");
98+
}))
99+
.expect_err("do_panic() did not panic!");
93100

94101
// See if we can extract the panic message.
95102
let msg = if let Some(s) = res.downcast_ref::<String>() {

0 commit comments

Comments
 (0)