Fix

itest/rust/src/rect2_test.rs

@@ -6,7 +6,10 @@
 use std::fmt::Debug;
 
 use crate::itest;
-use godot::prelude::{inner::InnerRect2, *};
+use godot::{
+    builtin::{Rect2, RectSide, Vector2},
+    prelude::inner::InnerRect2,
+};
 
 #[itest]
 fn rect2_equiv_unary() {
@@ -25,61 +28,65 @@ fn rect2_equiv_unary() {
         Vector2::new(10.0, 10.0),
     ];
     let test_reals = [0.0, 1.0, 10.0, 32.0];
+    let grow_values = [-1.0, 0.0, 1.0, 7.0];
     let test_sides = [
         RectSide::Left,
         RectSide::Top,
         RectSide::Right,
         RectSide::Bottom,
     ];
 
-    fn evaluate_mappings<T>(key: &str, a: T, b: T)
+    fn check_mapping_eq<T>(context: &str, outer: T, inner: T)
     where
         T: PartialEq + Debug,
     {
-        assert_eq!(a, b, "{}: outer != inner ({:?} != {:?})", key, a, b);
+        assert_eq!(
+            outer, inner,
+            "{context}: outer != inner ({outer:?} != {inner:?})"
+        );
     }
 
     for a in test_rects {
         let inner_a = InnerRect2::from_outer(&a);
 
-        evaluate_mappings("abs", a.abs(), inner_a.abs());
-        evaluate_mappings("area", a.area() as f64, inner_a.get_area());
-        evaluate_mappings("center", a.center(), inner_a.get_center());
-        evaluate_mappings("has_area", a.has_area(), inner_a.has_area());
+        check_mapping_eq("abs", a.abs(), inner_a.abs());
+        check_mapping_eq("area", a.area() as f64, inner_a.get_area());
+        check_mapping_eq("center", a.center(), inner_a.get_center());
+        check_mapping_eq("has_area", a.has_area(), inner_a.has_area());
 
         for b in test_rects {
-            evaluate_mappings("encloses", a.encloses(b), inner_a.encloses(b));
-            evaluate_mappings(
+            check_mapping_eq("encloses", a.encloses(b), inner_a.encloses(b));
+            check_mapping_eq(
                 "intersects",
                 a.intersects(b, true),
                 inner_a.intersects(b, true),
             );
             // Check intersection without considering borders
-            evaluate_mappings(
+            check_mapping_eq(
                 "intersects",
                 a.intersects(b, false),
                 inner_a.intersects(b, false),
             );
-            evaluate_mappings(
+            check_mapping_eq(
                 "intersection",
                 a.intersection(b).unwrap_or_default(),
                 inner_a.intersection(b),
             );
-            evaluate_mappings("merge", a.merge(b), inner_a.merge(b));
+            check_mapping_eq("merge", a.merge(b), inner_a.merge(b));
         }
 
         for b in test_vectors {
-            evaluate_mappings("expand", a.expand(b), inner_a.expand(b));
-            evaluate_mappings("has_point", a.has_point(b), inner_a.has_point(b));
+            check_mapping_eq("expand", a.expand(b), inner_a.expand(b));
+            check_mapping_eq("has_point", a.has_point(b), inner_a.has_point(b));
         }
 
-        for b in test_reals {
-            evaluate_mappings("grow", a.grow(b as f32), inner_a.grow(b));
+        for b in grow_values {
+            check_mapping_eq("grow", a.grow(b as f32), inner_a.grow(b));
 
-            for c in test_reals {
-                for d in test_reals {
-                    for e in test_reals {
-                        evaluate_mappings(
+            for c in grow_values {
+                for d in grow_values {
+                    for e in grow_values {
+                        check_mapping_eq(
                             "grow_individual",
                             a.grow_individual(b as f32, c as f32, d as f32, e as f32),
                             inner_a.grow_individual(b, c, d, e),
@@ -91,7 +98,7 @@ fn rect2_equiv_unary() {
 
         for b in test_sides {
             for c in test_reals {
-                evaluate_mappings(
+                check_mapping_eq(
                     "grow_side",
                     a.grow_side(b, c as f32),
                     inner_a.grow_side(b as i64, c),