Update tests

Author: lucic71

tests/unit/out/refcount/fft.rs

@@ -56,7 +56,8 @@ pub fn fft_3(a: Ptr<Option<Value<Box<[Complex]>>>>, mut N: i32) -> Option<Value<
     )));
     let mut i: i32 = 0;
     'loop_: while (i < N) {
-        let mut alpha: f64 = ((((-2_i32 as f64) * 3.141592654E+0) * (i as f64)) / (N as f64));
+        let mut alpha: f64 =
+            ((((-2_i32 as f64) * 3.1415926535897931E+0) * (i as f64)) / (N as f64));
         let __rhs = Complex {
             re: alpha.cos(),
             img: alpha.sin(),

tests/unit/out/refcount/reinterpret_cast_double.rs

@@ -15,7 +15,7 @@ fn main_0() -> i32 {
     let mut bits: Ptr<u64> = (d.as_pointer()).reinterpret_cast::<u64>();
     assert!(((bits.read()) == 4607182418800017408_u64));
     bits.write(4614256656552045848_u64);
-    assert!(((*d.borrow()) > 3.14E+0) && ((*d.borrow()) < 3.15E+0));
+    assert!(((*d.borrow()) > 3.1400000000000001E+0) && ((*d.borrow()) < 3.1499999999999999E+0));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {}

tests/unit/out/refcount/snprintf.rs

@@ -115,7 +115,7 @@ fn main_0() -> i32 {
         ((({
             let __s = libcc2rs::format_c(
                 &Ptr::<i8>::from_string_literal(b"%.2f").to_rust_string(),
-                &[(3.14159E+0).into()],
+                &[(3.1415899999999999E+0).into()],
             );
             let __b = __s.as_bytes();
             if ::std::mem::size_of::<[i8; 32]>() > 0 {
@@ -371,7 +371,7 @@ fn main_0() -> i32 {
         ((({
             let __s = libcc2rs::format_c(
                 &(fmt.as_pointer() as Ptr<i8>).to_rust_string(),
-                &[(3.26E+0).into()],
+                &[(3.2599999999999998E+0).into()],
             );
             let __b = __s.as_bytes();
             if ::std::mem::size_of::<[i8; 32]>() > 0 {

tests/unit/out/refcount/stdmin_fpoint.rs

@@ -11,7 +11,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let a0: Value<f64> = Rc::new(RefCell::new(3.14E+0));
+    let a0: Value<f64> = Rc::new(RefCell::new(3.1400000000000001E+0));
     let a1: Value<f64> = Rc::new(RefCell::new(2.71E+0));
     if a0.as_pointer().read() <= a1.as_pointer().read() {
         a0.as_pointer()

tests/unit/out/refcount/types.rs

@@ -40,6 +40,12 @@ fn main_0() -> i32 {
             == 352_u64)
     );
     assert!(((xld * 2_f64) == 3_f64));
+    let mut pi: f64 = 3.14159265358979E+0;
+    assert!((pi < 3.1415926540000001E+0));
+    let mut dmax: f64 = -1.7976931348623157E+308;
+    assert!((dmax < -1.0E+308));
+    let mut ldmax: f64 = f64::INFINITY;
+    assert!((ldmax > 1.7976931348623157E+308));
     assert!(((((xwc + (xc8 as i32)) + (xc16 as i32)) as u32).wrapping_add(xc32) == 266_u32));
     assert!((AnyPtr::default()).is_null());
     return 0;

tests/unit/out/refcount/union_basic.rs

@@ -53,8 +53,8 @@ fn main_0() -> i32 {
     &(*e.borrow_mut());
     basic::i(u.as_pointer()).write(42);
     assert!(((basic::i(u.as_pointer()).read()) == 42));
-    basic::f(u.as_pointer()).write(3.140000105E+0);
-    assert!(((basic::f(u.as_pointer()).read()) == 3.140000105E+0));
+    basic::f(u.as_pointer()).write(3.1400001E+0);
+    assert!(((basic::f(u.as_pointer()).read()) == 3.1400001E+0));
     let buf: Value<Box<[u8]>> = Rc::new(RefCell::new((0..4).map(|_| 0_u8).collect::<Box<[u8]>>()));
     {
         ((buf.as_pointer() as Ptr<u8>) as Ptr<u8>)

tests/unit/out/refcount/va_arg_mixed_types.rs

@@ -63,7 +63,12 @@ fn main_0() -> i32 {
         (((({
             sum_mixed_0(
                 2,
-                &[(1).into(), (3.7E+0).into(), (2).into(), (100_i64).into()],
+                &[
+                    (1).into(),
+                    (3.7000000000000002E+0).into(),
+                    (2).into(),
+                    (100_i64).into(),
+                ],
             )
         }) == 103) as i32)
             != 0)

tests/unit/out/unsafe/fft.rs

@@ -53,7 +53,8 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (N)) {
-        let mut alpha: f64 = ((((-2_i32 as f64) * (3.141592654E+0)) * (i as f64)) / (N as f64));
+        let mut alpha: f64 =
+            ((((-2_i32 as f64) * (3.1415926535897931E+0)) * (i as f64)) / (N as f64));
         w.as_mut().unwrap()[(i as usize)] = Complex {
             re: alpha.cos(),
             img: alpha.sin(),

tests/unit/out/unsafe/reinterpret_cast_double.rs

@@ -17,7 +17,7 @@ unsafe fn main_0() -> i32 {
     let mut bits: *mut u64 = ((&mut d as *mut f64) as *mut u64);
     assert!(((*bits) == (4607182418800017408_u64)));
     (*bits) = 4614256656552045848_u64;
-    assert!(((d) > (3.14E+0)) && ((d) < (3.15E+0)));
+    assert!(((d) > (3.1400000000000001E+0)) && ((d) < (3.1499999999999999E+0)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/snprintf.rs

@@ -77,7 +77,7 @@ unsafe fn main_0() -> i32 {
                 buf.as_mut_ptr() as *mut libc::c_char,
                 ::std::mem::size_of::<[libc::c_char; 32]>() as usize,
                 (c"%.2f".as_ptr().cast_mut()).cast_const() as *const libc::c_char,
-                (3.14159E+0),
+                (3.1415899999999999E+0),
             )
         }) == (4)) as i32)
             != 0)
@@ -226,7 +226,7 @@ unsafe fn main_0() -> i32 {
                 buf.as_mut_ptr() as *mut libc::c_char,
                 ::std::mem::size_of::<[libc::c_char; 32]>() as usize,
                 (fmt.as_mut_ptr()).cast_const() as *const libc::c_char,
-                (3.26E+0),
+                (3.2599999999999998E+0),
             )
         }) == (5)) as i32)
             != 0)