fix/tweak tests

Author: Strophox

src/tools/miri/tests/native-lib/pass/ptr_write_access.rs

@@ -13,6 +13,8 @@ fn main() {
 
     test_swap_ptr();
 
+    test_init_interior_mutable();
+
     test_dangling();
 }
 
@@ -43,56 +45,61 @@ fn test_init_int() {
 
 fn test_init_array() {
     extern "C" {
-        fn init_array(ptr: *mut i32, len: usize, value: i32);
+        fn init_array(ptr: *mut i32, len: usize);
     }
 
-    const LEN: usize = 4;
-    let init_value = 41;
+    const LEN: usize = 3;
 
     let mut array = MaybeUninit::<[i32; LEN]>::uninit();
     let array = unsafe {
-        init_array(array.as_mut_ptr().cast::<i32>(), LEN, init_value);
+        init_array(array.as_mut_ptr().cast::<i32>(), LEN);
         array.assume_init()
     };
 
-    assert_eq!(array, [init_value; LEN]);
+    assert_eq!(array, [31; LEN]);
 }
 
 fn test_swap_ptr() {
     extern "C" {
         fn swap_ptr(pptr0: *mut *const i32, pptr1: *mut *const i32);
     }
 
-    let x = 51;
-    let mut ptr0 = &x;
+    let x = 41;
+    let mut ptr0 = &raw const x;
     let mut ptr1 = std::ptr::null();
     unsafe { swap_ptr(&mut ptr0, &mut ptr1) };
 
     assert_eq!(unsafe { *ptr1 }, x);
 }
 
-fn test_init_static_inner() {
+fn test_init_interior_mutable() {
     extern "C" {
-        fn init_static_inner(pptr: *const *mut MaybeUninit<i32>);
+        fn init_interior_mutable(pptr: *const UnsafeInterior);
     }
 
-    static mut INNER: MaybeUninit<i32> = MaybeUninit::uninit();
-    static STATIC: *mut MaybeUninit<i32> = &raw mut INNER;
-    unsafe { init_static_inner(&STATIC) }
+    #[repr(C)]
+    struct UnsafeInterior {
+        mut_ptr: *mut i32
+    }
+    unsafe impl Sync for UnsafeInterior {}
+    
+    let mut x = MaybeUninit::<i32>::uninit();
+    let unsafe_interior = UnsafeInterior { mut_ptr: x.as_mut_ptr() };
+    unsafe { init_interior_mutable(&unsafe_interior) };
 
-    assert_eq!(unsafe { INNER.assume_init() }, 61);
+    assert_eq!(unsafe { x.assume_init() }, 51);
 }
 
 fn test_dangling() {
     extern "C" {
-        fn write_nullptr(pptr: *mut *const i32);
+        fn overwrite_ptr(pptr: *mut *const i32);
     }
 
-    let x = vec![71];
+    let x = vec![61];
     let mut ptr = x.as_ptr();
     drop(x);
-    unsafe { write_nullptr(&mut ptr) };
+    unsafe { overwrite_ptr(&mut ptr) };
     assert_eq!(ptr, std::ptr::null());
 }
 
-// TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.
+// TODO: Write tests for (forgetting to) expose: -initial allocation -recursively all allocations -unexposed pointers.

src/tools/miri/tests/native-lib/ptr_write_access.c

@@ -12,14 +12,14 @@ EXPORT void modify_int(int *ptr) {
 /* Test: test_init_int */
 
 EXPORT void init_int(int *ptr) {
-  *ptr = 12;
+  *ptr = 21;
 }
 
 /* Test: test_init_array */
 
-EXPORT void init_array(int *array, size_t len, int value) {
+EXPORT void init_array(int *array, size_t len) {
   for (size_t i = 0; i < len; i++) {
-    array[i] = value;
+    array[i] = 31;
   }
 }
 
@@ -31,14 +31,18 @@ EXPORT void swap_ptr(const int **pptr0, const int **pptr1) {
   *pptr1 = tmp;
 }
 
-/* Test: test_init_static_inner */
+/* Test: test_init_interior_mutable */
 
-EXPORT void init_static_inner(int **const pptr) {
-  **pptr = 1234;
+typedef struct UnsafeInterior {
+    int *mut_ptr;
+} UnsafeInterior;
+
+EXPORT void init_interior_mutable(const UnsafeInterior *u_ptr) {
+  *(u_ptr->mut_ptr) = 51;
 }
 
 /* Test: test_dangling */
 
-EXPORT void write_nullptr(const int **pptr) {
+EXPORT void overwrite_ptr(const int **pptr) {
   *pptr = NULL;
-}
+}