Update tests

lucic71 · lucic71 · commit 584573a0a17a · 2026-04-16T20:50:55.000+01:00
diff --git a/tests/ub/out/unsafe/ub10.rs b/tests/ub/out/unsafe/ub10.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut ptr: *mut i32 = arr.offset((1) as isize);
     let mut out: i32 = (*ptr);
 
diff --git a/tests/ub/out/unsafe/ub14.rs b/tests/ub/out/unsafe/ub14.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr1: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr1: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (*arr1.offset((100) as isize)) = 1;
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
diff --git a/tests/ub/out/unsafe/ub15.rs b/tests/ub/out/unsafe/ub15.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..15_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..15_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut ptr: *mut i32 = arr.offset((15) as isize);
     let mut out: i32 = (*ptr);
 
diff --git a/tests/ub/out/unsafe/ub16.rs b/tests/ub/out/unsafe/ub16.rs
@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p1: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut p1: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut out: i32 = (*(unsafe {
         let _a: *mut i32 = (&mut (*p1.offset((1) as isize)) as *mut i32);
         foo_0(_a)
diff --git a/tests/ub/out/unsafe/ub20.rs b/tests/ub/out/unsafe/ub20.rs
@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut x: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (unsafe {
         let _single: *mut i32 = x;
         foo_0(_single)
diff --git a/tests/ub/out/unsafe/ub9.rs b/tests/ub/out/unsafe/ub9.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut out: i32 = (*arr.offset((10) as isize));
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
diff --git a/tests/unit/out/unsafe/06_new_array.rs b/tests/unit/out/unsafe/06_new_array.rs
@@ -13,8 +13,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut e: *mut i32 =
-        Box::leak((0..2_u64).map(|_| <i32>::default()).collect::<Box<[i32]>>()).as_mut_ptr();
+    let mut e: *mut i32 = Box::leak((0..2_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     (*e.offset((0) as isize)) = 6;
     (*e.offset((1) as isize)) = 7;
 
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -22,10 +22,10 @@ pub struct Foo {
 impl Default for Foo {
     fn default() -> Self {
         Foo {
-            x: <i32>::default(),
+            x: 0_i32,
             y: <*mut i32>::default(),
             z: Default::default(),
-            a: [<i32>::default(); 3],
+            a: [0_i32; 3],
             bar: <Bar>::default(),
         }
     }
diff --git a/tests/unit/out/unsafe/default.rs b/tests/unit/out/unsafe/default.rs
@@ -22,7 +22,7 @@ impl Default for Pointers {
             x2: Default::default(),
             x3: [Default::default(); 5],
             x4: [Default::default(); 10],
-            x5: <i32>::default(),
+            x5: 0_i32,
         }
     }
 }
diff --git a/tests/unit/out/unsafe/init.rs b/tests/unit/out/unsafe/init.rs
@@ -20,7 +20,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: i32 = <i32>::default();
+    let mut x: i32 = 0_i32;
     let mut p: *mut i32 = Default::default();
     let g: *mut i32 = &mut x as *mut i32;
     let mut q: *mut i32 = (&mut x as *mut i32);
diff --git a/tests/unit/out/unsafe/init_list.rs b/tests/unit/out/unsafe/init_list.rs
@@ -15,9 +15,9 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut i1: i32 = 3;
-    let mut i2: i32 = <i32>::default();
+    let mut i2: i32 = 0_i32;
     let mut carr1: [i32; 2] = [1, 2];
-    let mut carr2: [i32; 3] = [1, <i32>::default(), <i32>::default()];
+    let mut carr2: [i32; 3] = [1, 0_i32, 0_i32];
     let mut arr: Vec<i32> = vec![1, 2, 3];
     let mut vec_: Vec<i32> = vec![1, 2, 3];
     (unsafe {
diff --git a/tests/unit/out/unsafe/memset.rs b/tests/unit/out/unsafe/memset.rs
@@ -14,12 +14,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let N: i32 = 3;
-    let mut arr: *mut i32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut i32 =
+        Box::leak((0..(N as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     {
         let byte_0 = (arr as *mut i32 as *mut ::libc::c_void) as *mut u8;
         for offset in 0..(::std::mem::size_of::<i32>() as u64 as u64).wrapping_mul((N as u64)) {
diff --git a/tests/unit/out/unsafe/new_alloc_array.rs b/tests/unit/out/unsafe/new_alloc_array.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut array: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut array: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     {
         let byte_0 = (array as *mut i32 as *mut ::libc::c_void) as *mut u8;
         for offset in 0..(::std::mem::size_of::<i32>() as u64 as u64).wrapping_mul(100_u64) {
diff --git a/tests/unit/out/unsafe/new_array.rs b/tests/unit/out/unsafe/new_array.rs
@@ -13,12 +13,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut array: *mut i32 = Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut array: *mut i32 =
+        Box::leak((0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         array,
diff --git a/tests/unit/out/unsafe/new_array_var_size.rs b/tests/unit/out/unsafe/new_array_var_size.rs
@@ -14,24 +14,16 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut N: i32 = 5;
-    let mut A: *mut i32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut A: *mut i32 =
+        Box::leak((0..(N as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         A,
         libcc2rs::malloc_usable_size(A as *mut ::libc::c_void) / ::std::mem::size_of::<i32>(),
     )));
     let N2: *mut i32 = &mut N as *mut i32;
-    let mut A2: *mut i32 = Box::leak(
-        (0..((*N2) as u64))
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut A2: *mut i32 =
+        Box::leak((0..((*N2) as u64)).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
 
     ::std::mem::drop(Box::from_raw(::std::slice::from_raw_parts_mut(
         A2,
diff --git a/tests/unit/out/unsafe/pointer_call_offset.rs b/tests/unit/out/unsafe/pointer_call_offset.rs
@@ -16,12 +16,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut p1: *mut i32 = Box::leak(
-        (0..10_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
-    )
-    .as_mut_ptr();
+    let mut p1: *mut i32 =
+        Box::leak((0..10_u64).map(|_| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();
     let mut i: u32 = 0_u32;
     'loop_: while ((i) < (10_u32)) {
         (*p1.offset((i) as isize)) = (i as i32);
diff --git a/tests/unit/out/unsafe/random.rs b/tests/unit/out/unsafe/random.rs
@@ -40,9 +40,9 @@ impl Pair {
 impl Default for Pair {
     fn default() -> Self {
         Pair {
-            x: <i32>::default(),
-            y: <i32>::default(),
-            a: [<i32>::default(); 5],
+            x: 0_i32,
+            y: 0_i32,
+            a: [0_i32; 5],
             r: <*mut i32>::default(),
             p: Default::default(),
             pair: Default::default(),
diff --git a/tests/unit/out/unsafe/reinterpret_cast_large_array.rs b/tests/unit/out/unsafe/reinterpret_cast_large_array.rs
@@ -14,12 +14,8 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let N: i32 = 10000;
-    let mut arr: *mut u32 = Box::leak(
-        (0..(N as u64))
-            .map(|_| <u32>::default())
-            .collect::<Box<[u32]>>(),
-    )
-    .as_mut_ptr();
+    let mut arr: *mut u32 =
+        Box::leak((0..(N as u64)).map(|_| 0_u32).collect::<Box<[u32]>>()).as_mut_ptr();
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
         (*arr.offset((i) as isize)) = 0_u32;
diff --git a/tests/unit/out/unsafe/reinterpret_cast_new_array.rs b/tests/unit/out/unsafe/reinterpret_cast_new_array.rs
@@ -14,7 +14,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut arr: *mut u32 =
-        Box::leak((0..2_u64).map(|_| <u32>::default()).collect::<Box<[u32]>>()).as_mut_ptr();
+        Box::leak((0..2_u64).map(|_| 0_u32).collect::<Box<[u32]>>()).as_mut_ptr();
     (*arr.offset((0) as isize)) = 67305985_u32;
     (*arr.offset((1) as isize)) = 134678021_u32;
     let mut bytes: *mut u8 = (arr as *mut u8);
diff --git a/tests/unit/out/unsafe/stdcopy.rs b/tests/unit/out/unsafe/stdcopy.rs
@@ -14,7 +14,7 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut input: [i32; 3] = [1, 2, 3];
-    let mut output: [i32; 3] = [<i32>::default(); 3];
+    let mut output: [i32; 3] = [0_i32; 3];
     {
         let mut outptr = output.as_mut_ptr().clone();
         let mut curr = input.as_mut_ptr().clone();
diff --git a/tests/unit/out/unsafe/swap_extended.rs b/tests/unit/out/unsafe/swap_extended.rs
@@ -94,7 +94,7 @@ unsafe fn main_0() -> i32 {
         (*h),
     );
     ::std::mem::drop(Box::from_raw(h));
-    let mut i: *mut i32 = Box::leak(Box::new([7, 8, <i32>::default()])).as_mut_ptr();
+    let mut i: *mut i32 = Box::leak(Box::new([7, 8, 0_i32])).as_mut_ptr();
     write!(
         std::fs::File::from_raw_fd(
             std::io::stdout()
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
@@ -72,19 +72,15 @@ pub unsafe fn Consume_1(mut safe_ptr: Option<Box<SafePointer>>) -> i32 {
 pub unsafe fn RndStuff_2() {
     let mut x1: Option<Box<[i32]>> = None;
     let mut x2: Option<Box<[i32]>> = Some(Box::from_raw(Box::leak(
-        (0..100_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
+        (0..100_u64).map(|_| 0_i32).collect::<Box<[i32]>>(),
     )));
     let mut i: i32 = 0;
     'loop_: while ((i) < (100)) {
         x2.as_mut().unwrap()[(i as u64) as usize] = 1;
         i.prefix_inc();
     }
     x2 = Some(Box::from_raw(Box::leak(
-        (0..200_u64)
-            .map(|_| <i32>::default())
-            .collect::<Box<[i32]>>(),
+        (0..200_u64).map(|_| 0_i32).collect::<Box<[i32]>>(),
     )));
     let mut i: i32 = 0;
     'loop_: while ((i) < (200)) {
diff --git a/tests/unit/out/unsafe/vector2.rs b/tests/unit/out/unsafe/vector2.rs
@@ -9,7 +9,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn fn_0(v: *mut Vec<i32>, mut v3: Vec<i32>) {
     (*v).push(20);
-    let mut x: i32 = <i32>::default();
+    let mut x: i32 = 0_i32;
     let mut v2: Vec<i32> = Vec::new();
     let mut v4: *mut Vec<i32> = (&mut v3 as *mut Vec<i32>);
     v2.push(0);

Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,8 @@ pub fn main() {`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`unsafe fn main_0() -> i32 {`
`16`		`- let mut arr: *mut i32 = Box::leak(`
`17`		`- (0..10_u64)`
`18`		`- .map(\|_\| <i32>::default())`
`19`		`- .collect::<Box<[i32]>>(),`
`20`		`- )`
`21`		`- .as_mut_ptr();`
	`16`	`+ let mut arr: *mut i32 =`
	`17`	`+ Box::leak((0..10_u64).map(\|_\| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();`
`22`	`18`	`let mut ptr: *mut i32 = arr.offset((1) as isize);`
`23`	`19`	`let mut out: i32 = (*ptr);`
`24`	`20`
Original file line number	Diff line number	Diff line change
`@@ -13,8 +13,7 @@ pub fn main() {`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`	`unsafe fn main_0() -> i32 {`
`16`		`- let mut e: *mut i32 =`
`17`		`- Box::leak((0..2_u64).map(\|_\| <i32>::default()).collect::<Box<[i32]>>()).as_mut_ptr();`
	`16`	`+ let mut e: *mut i32 = Box::leak((0..2_u64).map(\|_\| 0_i32).collect::<Box<[i32]>>()).as_mut_ptr();`
`18`	`17`	`(*e.offset((0) as isize)) = 6;`
`19`	`18`	`(*e.offset((1) as isize)) = 7;`
`20`	`19`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,10 @@ pub struct Foo {`
`22`	`22`	`impl Default for Foo {`
`23`	`23`	`fn default() -> Self {`
`24`	`24`	`Foo {`
`25`		`- x: <i32>::default(),`
	`25`	`+ x: 0_i32,`
`26`	`26`	`y: <*mut i32>::default(),`
`27`	`27`	`z: Default::default(),`
`28`		`- a: [<i32>::default(); 3],`
	`28`	`+ a: [0_i32; 3],`
`29`	`29`	`bar: <Bar>::default(),`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ impl Default for Pointers {`
`22`	`22`	`x2: Default::default(),`
`23`	`23`	`x3: [Default::default(); 5],`
`24`	`24`	`x4: [Default::default(); 10],`
`25`		`- x5: <i32>::default(),`
	`25`	`+ x5: 0_i32,`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ pub fn main() {`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`	`unsafe fn main_0() -> i32 {`
`23`		`- let mut x: i32 = <i32>::default();`
	`23`	`+ let mut x: i32 = 0_i32;`
`24`	`24`	`let mut p: *mut i32 = Default::default();`
`25`	`25`	`let g: mut i32 = &mut x as mut i32;`
`26`	`26`	`let mut q: mut i32 = (&mut x as mut i32);`