fix: Replace macro use in ordered_float tests (#5602)

* fix: Require macros feature for ordered_float tests

The tests make use of the py_run macro which is only available with the
macros feature enabled.

* Allow ordered_float tests to run without macros

Replace the py_run macro with a local function offering a simplified but
sufficient functionality

* Restore cast to f64 in ordered_float tests

* Format ordered float tests

* Add newsfragments entry

* Remove unnecessary all in cfg(all(test)) attribute

* Delete newsfragments/5602.misc.md

* Use &CStr instead of requiring format!()

---------

Co-authored-by: David Hewitt <[email protected]>

Author: tpoliaw

src/conversions/ordered_float.rs

@@ -101,12 +101,19 @@ float_conversions!(NotNan, f64, |val| NotNan::new(val)
 #[cfg(test)]
 mod test_ordered_float {
     use super::*;
-    use crate::py_run;
+    use crate::types::dict::IntoPyDict;
     use crate::types::PyAnyMethods;
+    use std::ffi::CStr;
+    use std::ffi::CString;
 
     #[cfg(not(target_arch = "wasm32"))]
     use proptest::prelude::*;
 
+    fn py_run<'py>(py: Python<'py>, script: &CStr, locals: impl IntoPyDict<'py>) {
+        py.run(script, None, Some(&locals.into_py_dict(py).unwrap()))
+            .unwrap()
+    }
+
     macro_rules! float_roundtrip_tests {
         ($wrapper:ident, $float_type:ty, $constructor:expr, $standard_test:ident, $wasm_test:ident, $infinity_test:ident, $zero_test:ident) => {
             #[cfg(not(target_arch = "wasm32"))]
@@ -118,15 +125,11 @@ mod test_ordered_float {
                 Python::attach(|py| {
                     let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
 
-                    py_run!(
-                        py,
-                        f_py,
-                        &format!(
+                    py_run(py, &CString::new(format!(
                             "import math\nassert math.isclose(f_py, {})",
                              inner_f as f64 // Always interpret the literal rs float value as f64
                                             // so that it's comparable with the python float
-                        )
-                    );
+                        )).unwrap(), [("f_py", &f_py)]);
 
                     let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
 
@@ -142,16 +145,17 @@ mod test_ordered_float {
                 let f = $constructor(inner_f);
 
                 Python::attach(|py| {
-                    let f_py: Bound<'_, PyFloat>  = f.into_pyobject(py).unwrap();
+                    let f_py: Bound<'_, PyFloat> = f.into_pyobject(py).unwrap();
 
-                    py_run!(
+                    py_run(
                         py,
-                        f_py,
-                        &format!(
+                        &CString::new(format!(
                             "import math\nassert math.isclose(f_py, {})",
                             inner_f as f64 // Always interpret the literal rs float value as f64
                                            // so that it's comparable with the python float
-                        )
+                        ))
+                        .unwrap(),
+                        [("f_py", &f_py)],
                     );
 
                     let roundtripped_f: $wrapper<$float_type> = f_py.extract().unwrap();
@@ -169,15 +173,15 @@ mod test_ordered_float {
                 let ninf = $constructor(inner_ninf);
 
                 Python::attach(|py| {
-                    let pinf_py: Bound<'_, PyFloat>  = pinf.into_pyobject(py).unwrap();
-                    let ninf_py: Bound<'_, PyFloat>  = ninf.into_pyobject(py).unwrap();
+                    let pinf_py: Bound<'_, PyFloat> = pinf.into_pyobject(py).unwrap();
+                    let ninf_py: Bound<'_, PyFloat> = ninf.into_pyobject(py).unwrap();
 
-                    py_run!(
+                    py_run(
                         py,
-                        pinf_py ninf_py,
-                        "\
+                        c"\
                         assert pinf_py == float('inf')\n\
-                        assert ninf_py == float('-inf')"
+                        assert ninf_py == float('-inf')",
+                        [("pinf_py", &pinf_py), ("ninf_py", &ninf_py)],
                     );
 
                     let roundtripped_pinf: $wrapper<$float_type> = pinf_py.extract().unwrap();
@@ -197,20 +201,20 @@ mod test_ordered_float {
                 let nzero = $constructor(inner_nzero);
 
                 Python::attach(|py| {
-                    let pzero_py: Bound<'_, PyFloat>  = pzero.into_pyobject(py).unwrap();
-                    let nzero_py: Bound<'_, PyFloat>  = nzero.into_pyobject(py).unwrap();
+                    let pzero_py: Bound<'_, PyFloat> = pzero.into_pyobject(py).unwrap();
+                    let nzero_py: Bound<'_, PyFloat> = nzero.into_pyobject(py).unwrap();
 
                     // This python script verifies that the values are 0.0 in magnitude
                     // and that the signs are correct(+0.0 vs -0.0)
-                    py_run!(
+                    py_run(
                         py,
-                        pzero_py nzero_py,
-                        "\
+                        c"\
                         import math\n\
                         assert pzero_py == 0.0\n\
                         assert math.copysign(1.0, pzero_py) > 0.0\n\
                         assert nzero_py == 0.0\n\
-                        assert math.copysign(1.0, nzero_py) < 0.0"
+                        assert math.copysign(1.0, nzero_py) < 0.0",
+                        [("pzero_py", &pzero_py), ("nzero_py", &nzero_py)],
                     );
 
                     let roundtripped_pzero: $wrapper<$float_type> = pzero_py.extract().unwrap();
@@ -271,12 +275,10 @@ mod test_ordered_float {
                 Python::attach(|py| {
                     let nan_py: Bound<'_, PyFloat> = nan.into_pyobject(py).unwrap();
 
-                    py_run!(
+                    py_run(
                         py,
-                        nan_py,
-                        "\
-                        import math\n\
-                        assert math.isnan(nan_py)"
+                        c"import math\nassert math.isnan(nan_py)",
+                        [("nan_py", &nan_py)],
                     );
 
                     let roundtripped_nan: OrderedFloat<$float_type> = nan_py.extract().unwrap();