transpile: Fix f128.c snapshot test

c2rust-transpile/tests/snapshots.rs

@@ -436,6 +436,14 @@ fn test_call_only_once() {
     transpile("call_only_once.c").os_specific(true).run();
 }
 
+#[test]
+fn test_f128() {
+    transpile("f128.c")
+        .expect_compile_error(true)
+        .os_specific(true)
+        .run();
+}
+
 #[test]
 fn test_macros_os_specific() {
     transpile("macros.c").os_specific(true).run();

c2rust-transpile/tests/snapshots/f128.c → c2rust-transpile/tests/snapshots/os-specific/f128.c

@@ -18,6 +18,8 @@ void long_double_test(void) {
     }
 }
 
+#if defined(__x86_64__) || defined(__i386__)
+
 void float128_test(void) {
     __float128 one = 1.0q;
     __float128 zero;
@@ -35,3 +37,5 @@ void float128_test(void) {
         int dummy;
     }
 }
+
+#endif

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.2021.snap → c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2021.linux.snap

@@ -1,6 +1,6 @@
 ---
 source: c2rust-transpile/tests/snapshots.rs
-expression: cat tests/snapshots/f128.2021.rs
+expression: cat tests/snapshots/os-specific/f128.c.2021.linux.rs
 ---
 #![allow(
     dead_code,
@@ -11,7 +11,7 @@ expression: cat tests/snapshots/f128.2021.rs
     unused_mut
 )]
 #![deny(unsafe_op_in_unsafe_fn)]
-use ::num_traits::Float;
+use ::num_traits::{Float, ToPrimitive};
 #[no_mangle]
 pub unsafe extern "C" fn long_double_test() {
     unsafe {
@@ -24,7 +24,11 @@ pub unsafe extern "C" fn long_double_test() {
         let mut cast_from_int: ::f128::f128 = ::f128::f128::new(i);
         let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
         let mut is_inf: bool = if huge.is_infinite() {
-            if huge.is_sign_positive() { 1 } else { -1 }
+            if huge.is_sign_positive() {
+                1
+            } else {
+                -1
+            }
         } else {
             0
         } != 0;
@@ -46,7 +50,11 @@ pub unsafe extern "C" fn float128_test() {
         let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
         let mut ld_from_float128: ::f128::f128 = one;
         let mut is_inf: bool = if huge.is_infinite() {
-            if huge.is_sign_positive() { 1 } else { -1 }
+            if huge.is_sign_positive() {
+                1
+            } else {
+                -1
+            }
         } else {
             0
         } != 0;

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2021.macos.snap

@@ -0,0 +1,59 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/os-specific/f128.c.2021.macos.rs
+---
+#![allow(
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![deny(unsafe_op_in_unsafe_fn)]
+use ::num_traits::{Float, ToPrimitive};
+#[inline(always)]
+unsafe extern "C" fn __inline_isinff(mut __x: ::core::ffi::c_float) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::core::f32::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[inline(always)]
+unsafe extern "C" fn __inline_isinfd(mut __x: ::core::ffi::c_double) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::core::f64::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[inline(always)]
+unsafe extern "C" fn __inline_isinfl(mut __x: ::f128::f128) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::f128::f128::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[no_mangle]
+pub unsafe extern "C" fn long_double_test() {
+    unsafe {
+        let mut one: ::f128::f128 = ::f128::f128::new(1.0);
+        let mut zero: ::f128::f128 = ::f128::f128::ZERO;
+        let mut add: ::f128::f128 = one + zero;
+        let mut huge: ::f128::f128 = ::f128::f128::INFINITY;
+        let mut i: ::core::ffi::c_int = one.to_i32().unwrap();
+        let mut f: ::core::ffi::c_float = one.to_f32().unwrap();
+        let mut cast_from_int: ::f128::f128 = ::f128::f128::new(i);
+        let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
+        let mut is_inf: bool = if ::core::mem::size_of::<::f128::f128>() as usize
+            == ::core::mem::size_of::<::core::ffi::c_float>() as usize
+        {
+            __inline_isinff(huge.to_f32().unwrap())
+        } else if ::core::mem::size_of::<::f128::f128>() as usize
+            == ::core::mem::size_of::<::core::ffi::c_double>() as usize
+        {
+            __inline_isinfd(huge.to_f64().unwrap())
+        } else {
+            __inline_isinfl(huge)
+        } != 0;
+        if one != ::f128::f128::ZERO {
+            let mut dummy: ::core::ffi::c_int = 0;
+        }
+    }
+}

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.2024.snap → c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2024.linux.snap

@@ -1,6 +1,6 @@
 ---
 source: c2rust-transpile/tests/snapshots.rs
-expression: cat tests/snapshots/f128.2024.rs
+expression: cat tests/snapshots/os-specific/f128.c.2024.linux.rs
 ---
 #![allow(
     dead_code,
@@ -11,7 +11,7 @@ expression: cat tests/snapshots/f128.2024.rs
     unused_mut
 )]
 #![deny(unsafe_op_in_unsafe_fn)]
-use ::num_traits::Float;
+use ::num_traits::{Float, ToPrimitive};
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn long_double_test() {
     unsafe {

c2rust-transpile/tests/snapshots/snapshots__transpile@f128.c.2024.macos.snap

@@ -0,0 +1,59 @@
+---
+source: c2rust-transpile/tests/snapshots.rs
+expression: cat tests/snapshots/os-specific/f128.c.2024.macos.rs
+---
+#![allow(
+    dead_code,
+    non_camel_case_types,
+    non_snake_case,
+    non_upper_case_globals,
+    unused_assignments,
+    unused_mut
+)]
+#![deny(unsafe_op_in_unsafe_fn)]
+use ::num_traits::{Float, ToPrimitive};
+#[inline(always)]
+unsafe extern "C" fn __inline_isinff(mut __x: ::core::ffi::c_float) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::core::f32::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[inline(always)]
+unsafe extern "C" fn __inline_isinfd(mut __x: ::core::ffi::c_double) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::core::f64::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[inline(always)]
+unsafe extern "C" fn __inline_isinfl(mut __x: ::f128::f128) -> ::core::ffi::c_int {
+    unsafe {
+        return (__x.abs() == ::f128::f128::INFINITY) as ::core::ffi::c_int;
+    }
+}
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn long_double_test() {
+    unsafe {
+        let mut one: ::f128::f128 = ::f128::f128::new(1.0);
+        let mut zero: ::f128::f128 = ::f128::f128::ZERO;
+        let mut add: ::f128::f128 = one + zero;
+        let mut huge: ::f128::f128 = ::f128::f128::INFINITY;
+        let mut i: ::core::ffi::c_int = one.to_i32().unwrap();
+        let mut f: ::core::ffi::c_float = one.to_f32().unwrap();
+        let mut cast_from_int: ::f128::f128 = ::f128::f128::new(i);
+        let mut cast_from_float: ::f128::f128 = ::f128::f128::new(f);
+        let mut is_inf: bool = if ::core::mem::size_of::<::f128::f128>() as usize
+            == ::core::mem::size_of::<::core::ffi::c_float>() as usize
+        {
+            __inline_isinff(huge.to_f32().unwrap())
+        } else if ::core::mem::size_of::<::f128::f128>() as usize
+            == ::core::mem::size_of::<::core::ffi::c_double>() as usize
+        {
+            __inline_isinfd(huge.to_f64().unwrap())
+        } else {
+            __inline_isinfl(huge)
+        } != 0;
+        if one != ::f128::f128::ZERO {
+            let mut dummy: ::core::ffi::c_int = 0;
+        }
+    }
+}