gh-50 Add tests to improve code coverage for spatial predicates

Add tests for:
- FixedScaleFloatRelate: disjoint_with_fixed_scale, covers_with_fixed_scale
- FloatOverlay: with_subj_and_clip_fixed_scale_custom
- FloatPredicateOverlay: with_adapter, with_adapter_custom, with_subj_and_clip_custom, clear
- Error handling for invalid scale values across all fixed-scale methods

Author: bretttully

iOverlay/src/float/relate.rs

@@ -520,4 +520,102 @@ mod tests {
         assert!(!left.within(&right));
         assert!(!left.covers(&right));
     }
+
+    #[test]
+    fn test_predicate_overlay_with_adapter() {
+        use crate::core::overlay::ShapeType;
+        use i_float::adapter::FloatPointAdapter;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let iter = square.iter().chain(other.iter());
+        let adapter = FloatPointAdapter::with_iter(iter);
+
+        let mut overlay = FloatPredicateOverlay::with_adapter(adapter, 16);
+        overlay.add_source(&square, ShapeType::Subject);
+        overlay.add_source(&other, ShapeType::Clip);
+        assert!(overlay.intersects());
+    }
+
+    #[test]
+    fn test_predicate_overlay_with_adapter_custom() {
+        use crate::core::fill_rule::FillRule;
+        use crate::core::overlay::ShapeType;
+        use crate::core::solver::Solver;
+        use i_float::adapter::FloatPointAdapter;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let iter = square.iter().chain(other.iter());
+        let adapter = FloatPointAdapter::with_iter(iter);
+
+        let mut overlay =
+            FloatPredicateOverlay::with_adapter_custom(adapter, FillRule::NonZero, Solver::default(), 16);
+        overlay.add_source(&square, ShapeType::Subject);
+        overlay.add_source(&other, ShapeType::Clip);
+        assert!(overlay.intersects());
+    }
+
+    #[test]
+    fn test_predicate_overlay_with_subj_and_clip_custom() {
+        use crate::core::fill_rule::FillRule;
+        use crate::core::solver::Solver;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let mut overlay = FloatPredicateOverlay::with_subj_and_clip_custom(
+            &square,
+            &other,
+            FillRule::NonZero,
+            Solver::default(),
+        );
+        assert!(overlay.intersects());
+    }
+
+    #[test]
+    fn test_predicate_overlay_clear() {
+        use crate::core::overlay::ShapeType;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let mut overlay = FloatPredicateOverlay::with_subj_and_clip(&square, &other);
+        assert!(overlay.intersects());
+
+        overlay.clear();
+
+        // Use coordinates within the original adapter bounds
+        let touching = vec![[10.0, 0.0], [10.0, 10.0], [15.0, 10.0], [15.0, 0.0]];
+        overlay.add_source(&square, ShapeType::Subject);
+        overlay.add_source(&touching, ShapeType::Clip);
+        // After clear and re-add, shapes touch but don't overlap interiors
+        assert!(overlay.intersects());
+    }
+
+    #[test]
+    fn test_predicate_overlay_all_predicates() {
+        let outer = vec![[0.0, 0.0], [0.0, 20.0], [20.0, 20.0], [20.0, 0.0]];
+        let inner = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let mut overlay = FloatPredicateOverlay::with_subj_and_clip(&inner, &outer);
+        assert!(overlay.intersects());
+
+        overlay.clear();
+        overlay.add_source(&inner, crate::core::overlay::ShapeType::Subject);
+        overlay.add_source(&outer, crate::core::overlay::ShapeType::Clip);
+        assert!(overlay.interiors_intersect());
+
+        overlay.clear();
+        overlay.add_source(&inner, crate::core::overlay::ShapeType::Subject);
+        overlay.add_source(&outer, crate::core::overlay::ShapeType::Clip);
+        assert!(!overlay.touches());
+
+        overlay.clear();
+        overlay.add_source(&inner, crate::core::overlay::ShapeType::Subject);
+        overlay.add_source(&outer, crate::core::overlay::ShapeType::Clip);
+        assert!(overlay.within());
+    }
 }

iOverlay/src/float/scale.rs

@@ -505,4 +505,144 @@ mod tests {
             FloatPredicateOverlay::with_subj_and_clip_fixed_scale(&square, &other, f64::INFINITY).is_err()
         );
     }
+
+    #[test]
+    fn test_disjoint_with_fixed_scale() {
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[20.0, 20.0], [20.0, 30.0], [30.0, 30.0], [30.0, 20.0]];
+
+        let result = square.disjoint_with_fixed_scale(&other, 1000.0);
+        assert!(result.unwrap());
+
+        let overlapping = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+        let result = square.disjoint_with_fixed_scale(&overlapping, 1000.0);
+        assert!(!result.unwrap());
+    }
+
+    #[test]
+    fn test_covers_with_fixed_scale() {
+        let outer = vec![[0.0, 0.0], [0.0, 20.0], [20.0, 20.0], [20.0, 0.0]];
+        let inner = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let result = outer.covers_with_fixed_scale(&inner, 1000.0);
+        assert!(result.unwrap());
+
+        let result = inner.covers_with_fixed_scale(&outer, 1000.0);
+        assert!(!result.unwrap());
+    }
+
+    #[test]
+    fn test_fixed_scale_custom_overlay() {
+        use crate::core::solver::Solver;
+
+        let left_rect = vec![[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]];
+        let right_rect = vec![[1.0, 0.0], [1.0, 1.0], [2.0, 1.0], [2.0, 0.0]];
+
+        let shapes = FloatOverlay::with_subj_and_clip_fixed_scale_custom(
+            &left_rect,
+            &right_rect,
+            Default::default(),
+            Solver::default(),
+            10.0,
+        )
+        .unwrap()
+        .overlay(OverlayRule::Union, FillRule::EvenOdd);
+
+        assert_eq!(shapes.len(), 1);
+        assert_eq!(shapes[0].len(), 1);
+        assert_eq!(shapes[0][0].len(), 4);
+    }
+
+    #[test]
+    fn test_fixed_scale_custom_overlay_invalid() {
+        use crate::core::solver::Solver;
+
+        let left_rect = vec![[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]];
+        let right_rect = vec![[1.0, 0.0], [1.0, 1.0], [2.0, 1.0], [2.0, 0.0]];
+
+        let result = FloatOverlay::with_subj_and_clip_fixed_scale_custom(
+            &left_rect,
+            &right_rect,
+            Default::default(),
+            Solver::default(),
+            -1.0,
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fixed_scale_custom_overlay_scale_too_large() {
+        use crate::core::solver::Solver;
+
+        let left_rect = vec![[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]];
+        let right_rect = vec![[1.0, 0.0], [1.0, 1.0], [2.0, 1.0], [2.0, 0.0]];
+
+        let scale = (1u64 << 32) as f64;
+        let result = FloatOverlay::with_subj_and_clip_fixed_scale_custom(
+            &left_rect,
+            &right_rect,
+            Default::default(),
+            Solver::default(),
+            scale,
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_predicate_overlay_with_fixed_scale_custom() {
+        use crate::core::solver::Solver;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let mut overlay = FloatPredicateOverlay::with_subj_and_clip_fixed_scale_custom(
+            &square,
+            &other,
+            FillRule::NonZero,
+            Solver::default(),
+            1000.0,
+        )
+        .unwrap();
+        assert!(overlay.intersects());
+    }
+
+    #[test]
+    fn test_predicate_overlay_with_fixed_scale_custom_invalid() {
+        use crate::core::solver::Solver;
+
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        let result = FloatPredicateOverlay::with_subj_and_clip_fixed_scale_custom(
+            &square,
+            &other,
+            FillRule::NonZero,
+            Solver::default(),
+            -1.0,
+        );
+        assert!(result.is_err());
+
+        let scale = (1u64 << 32) as f64;
+        let result = FloatPredicateOverlay::with_subj_and_clip_fixed_scale_custom(
+            &square,
+            &other,
+            FillRule::NonZero,
+            Solver::default(),
+            scale,
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_fixed_scale_relate_invalid_scale() {
+        let square = vec![[0.0, 0.0], [0.0, 10.0], [10.0, 10.0], [10.0, 0.0]];
+        let other = vec![[5.0, 5.0], [5.0, 15.0], [15.0, 15.0], [15.0, 5.0]];
+
+        assert!(square.intersects_with_fixed_scale(&other, -1.0).is_err());
+        assert!(square.interiors_intersect_with_fixed_scale(&other, -1.0).is_err());
+        assert!(square.touches_with_fixed_scale(&other, -1.0).is_err());
+        assert!(square.within_with_fixed_scale(&other, -1.0).is_err());
+        assert!(square.disjoint_with_fixed_scale(&other, -1.0).is_err());
+        assert!(square.covers_with_fixed_scale(&other, -1.0).is_err());
+    }
 }