make another test more robust against random alignment

diff --git a/tests/compile-fail/unaligned_pointers/alignment.rs b/tests/compile-fail/unaligned_pointers/alignment.rs
index 8532f91a5c0060ae77a5e8cf182df6d1409c31ce..e4d7621b8b125d278e4a835916b24b74b70242ea 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/alignment.rs
+++ b/tests/compile-fail/unaligned_pointers/alignment.rs
@@ -1,11 +1,11 @@
+// error-pattern: but alignment 4 is required
+
 fn main() {
     let mut x = [0u8; 20];
     let x_ptr: *mut u8 = x.as_mut_ptr();
     // At least one of these is definitely unaligned.
-    // Currently, we guarantee to complain about the first one already (https://github.com/rust-lang/miri/issues/1074).
     unsafe {
-        *(x_ptr as *mut u64) = 42; //~ ERROR accessing memory with alignment 1, but alignment
-        *(x_ptr.add(1) as *mut u64) = 42;
+        *(x_ptr as *mut u32) = 42;
+        *(x_ptr.add(1) as *mut u32) = 42;
     }
-    panic!("unreachable in miri");
 }

diff --git a/tests/compile-fail/unaligned_pointers/reference_to_packed.rs b/tests/compile-fail/unaligned_pointers/reference_to_packed.rs
index a1240c90182aa8ff5cf986596a460e9cba5060bf..998394c6c70cce11eeac1db27969b0ca3439b413 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/reference_to_packed.rs
+++ b/tests/compile-fail/unaligned_pointers/reference_to_packed.rs
@@ -10,10 +10,12 @@ struct Foo {
 }
 
 fn main() {
-    let foo = Foo {
-        x: 42,
-        y: 99,
-    };
-    let p = unsafe { &foo.x };
-    let i = *p; //~ ERROR alignment 4 is required
+    for _ in 0..10 { // Try many times as this might work by chance.
+        let foo = Foo {
+            x: 42,
+            y: 99,
+        };
+        let p = unsafe { &foo.x };
+        let i = *p; //~ ERROR alignment 4 is required
+    }
 }

diff --git a/tests/compile-fail/unaligned_pointers/unaligned_ptr1.rs b/tests/compile-fail/unaligned_pointers/unaligned_ptr1.rs
index 0a67cfc5a1b362ead0f71b7a38b52d4398f2d4ed..43e6fd67d2460c0c350f6532f27450be0722f66b 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/unaligned_ptr1.rs
+++ b/tests/compile-fail/unaligned_pointers/unaligned_ptr1.rs
@@ -2,8 +2,10 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
-    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.
-    let _x = unsafe { *x }; //~ ERROR memory with alignment 2, but alignment 4 is required
+    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.
+        let _x = unsafe { *x }; //~ ERROR memory with alignment 2, but alignment 4 is required
+    }
 }

diff --git a/tests/compile-fail/unaligned_pointers/unaligned_ptr2.rs b/tests/compile-fail/unaligned_pointers/unaligned_ptr2.rs
index b1fb2f4aa9762646d9ec8705bdab8cec1b355e9f..f4ed8d47b53f1a70edbe3b85ee9c5e75710d6388 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/unaligned_ptr2.rs
+++ b/tests/compile-fail/unaligned_pointers/unaligned_ptr2.rs
@@ -2,9 +2,11 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
-    let x = [2u32, 3]; // Make it big enough so we don't get an out-of-bounds error.
-    let x = (x.as_ptr() as *const u8).wrapping_offset(3) as *const u32;
-    // This must fail because alignment is violated: the offset is not sufficiently aligned.
-    // Also make the offset not a power of 2, that used to ICE.
-    let _x = unsafe { *x }; //~ ERROR memory with alignment 1, but alignment 4 is required
+    for _ in 0..10 { // Try many times as this might work by chance.
+        let x = [2u32, 3]; // Make it big enough so we don't get an out-of-bounds error.
+        let x = (x.as_ptr() as *const u8).wrapping_offset(3) as *const u32;
+        // This must fail because alignment is violated: the offset is not sufficiently aligned.
+        // Also make the offset not a power of 2, that used to ICE.
+        let _x = unsafe { *x }; //~ ERROR memory with alignment 1, but alignment 4 is required
+    }
 }

diff --git a/tests/compile-fail/unaligned_pointers/unaligned_ptr3.rs b/tests/compile-fail/unaligned_pointers/unaligned_ptr3.rs
index c5a3398384e495ea6830b306c83345825288de2d..61c2a3cde8948c73ae186446a6306dd5b6933a3b 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/unaligned_ptr3.rs
+++ b/tests/compile-fail/unaligned_pointers/unaligned_ptr3.rs
@@ -2,10 +2,12 @@
 // compile-flags: -Zmiri-disable-validation -Zmiri-disable-stacked-borrows
 
 fn main() {
-    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,
-    // which have special code in miri's memory.
-    let _x = unsafe { *x };
-    //~^ ERROR memory with alignment 2, but alignment
+    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,
+        // which have special code in miri's memory.
+        let _x = unsafe { *x };
+        //~^ ERROR but alignment
+    }
 }

diff --git a/tests/compile-fail/unaligned_pointers/unaligned_ptr_addr_of.rs b/tests/compile-fail/unaligned_pointers/unaligned_ptr_addr_of.rs
index cd52cd44c2b2cc3b2914a35dc6f1a89ee75e223a..88e2634efaf61642b878261c91a1e9861ba275df 100644 (file)
--- a/tests/compile-fail/unaligned_pointers/unaligned_ptr_addr_of.rs
+++ b/tests/compile-fail/unaligned_pointers/unaligned_ptr_addr_of.rs
@@ -4,9 +4,11 @@
 use std::ptr;
 
 fn main() {
-    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.
-    // The deref is UB even if we just put the result into a raw pointer.
-    let _x = unsafe { ptr::raw_const!(*x) }; //~ ERROR memory with alignment 2, but alignment 4 is required
+    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.
+        // The deref is UB even if we just put the result into a raw pointer.
+        let _x = unsafe { ptr::raw_const!(*x) }; //~ ERROR memory with alignment 2, but alignment 4 is required
+    }
 }