test(geometry): Achieve 100% test coverage for BentleyOttmann

Author: Microindole

src/main/java/com/thealgorithms/geometry/BentleyOttmann.java

@@ -1,7 +1,16 @@
 package com.thealgorithms.geometry;
 
 import java.awt.geom.Point2D;
-import java.util.*;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.List;
+import java.util.PriorityQueue;
+import java.util.TreeSet;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.ArrayList;
 
 /**
  * Implementation of the Bentley–Ottmann algorithm for finding all intersection
@@ -102,7 +111,9 @@ public int compareTo(Event other) {
 
         @Override
         public boolean equals(Object o) {
-            if (!(o instanceof Event e)) return false;
+            if (!(o instanceof Event e)) {
+                return false;
+            }
             return pointsEqual(this.point, e.point);
         }
 
@@ -116,10 +127,12 @@ public int hashCode() {
      * Comparator for segments in the status structure (sweep line).
      * Orders segments by their y-coordinate at the current sweep line position.
      */
-    private static class StatusComparator implements Comparator<Segment> {
+    private final static class StatusComparator implements Comparator<Segment> {
         @Override
         public int compare(Segment s1, Segment s2) {
-            if (s1.id == s2.id) return 0;
+            if (s1.id == s2.id) {
+                return 0;
+            }
 
             double y1 = s1.getY(currentSweepX);
             double y2 = s2.getY(currentSweepX);
@@ -271,7 +284,9 @@ private static void handleEvent(Event event, TreeSet<Segment> status, PriorityQu
     }
 
     private static Segment getNeighbor(TreeSet<Segment> status, Set<Segment> removed, boolean lower) {
-        if (removed.isEmpty()) return null;
+        if (removed.isEmpty()) {
+            return null;
+        }
         Segment ref = removed.iterator().next();
         return lower ? status.lower(ref) : status.higher(ref);
     }
@@ -324,10 +339,14 @@ private static void findNewEvent(Segment s1, Segment s2, Point2D.Double currentP
     }
 
     private static Point2D.Double getIntersection(Segment s1, Segment s2) {
-        double x1 = s1.p1.x, y1 = s1.p1.y;
-        double x2 = s1.p2.x, y2 = s1.p2.y;
-        double x3 = s2.p1.x, y3 = s2.p1.y;
-        double x4 = s2.p2.x, y4 = s2.p2.y;
+        double x1 = s1.p1.x;
+        double y1 = s1.p1.y;
+        double x2 = s1.p2.x;
+        double y2 = s1.p2.y;
+        double x3 = s2.p1.x;
+        double y3 = s2.p1.y;
+        double x4 = s2.p2.x;
+        double y4 = s2.p2.y;
 
         double denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
 
@@ -338,10 +357,18 @@ private static Point2D.Double getIntersection(Segment s1, Segment s2) {
                 // Return any overlapping point
                 List<Point2D.Double> overlapPoints = new ArrayList<>();
 
-                if (onSegment(s1, s2.p1)) overlapPoints.add(s2.p1);
-                if (onSegment(s1, s2.p2)) overlapPoints.add(s2.p2);
-                if (onSegment(s2, s1.p1)) overlapPoints.add(s1.p1);
-                if (onSegment(s2, s1.p2)) overlapPoints.add(s1.p2);
+                if (onSegment(s1, s2.p1)) {
+                    overlapPoints.add(s2.p1);
+                }
+                if (onSegment(s1, s2.p2)) {
+                    overlapPoints.add(s2.p2);
+                }
+                if (onSegment(s2, s1.p1)) {
+                    overlapPoints.add(s1.p1);
+                }
+                if (onSegment(s2, s1.p2)) {
+                    overlapPoints.add(s1.p2);
+                }
 
                 // Remove duplicates and return the first point
                 if (!overlapPoints.isEmpty()) {

src/test/java/com/thealgorithms/geometry/BentleyOttmannTest.java

@@ -1,6 +1,10 @@
 package com.thealgorithms.geometry;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import java.awt.geom.Point2D;
 import java.util.ArrayList;
@@ -49,10 +53,7 @@ void testNoIntersection() {
 
     @Test
     void testCoincidentSegments() {
-        List<Object> segments = List.of(
-                newSegment(1, 1, 5, 5),
-                newSegment(1, 1, 5, 5)
-        );
+        List<Object> segments = List.of(newSegment(1, 1, 5, 5), newSegment(1, 1, 5, 5));
 
         Set<Point2D.Double> intersections = BentleyOttmann.findIntersections(cast(segments));
 
@@ -162,15 +163,15 @@ void testGridPattern() {
         // Verify all grid points are present
         for (int x = 0; x <= 2; x++) {
             for (int y = 0; y <= 2; y++) {
-                assertTrue(containsPoint(intersections, x, y), String.format("Grid point (%d, %d) should be present", x, y));            }
+                assertTrue(containsPoint(intersections, x, y), String.format("Grid point (%d, %d) should be present", x, y));
+            }
         }
     }
 
     @Test
     void testTriangleIntersections() {
         // Three segments forming a triangle
-        List<Object> segments = List.of(
-                newSegment(0, 0, 4, 0), // base
+        List<Object> segments = List.of(newSegment(0, 0, 4, 0), // base
                 newSegment(0, 0, 2, 3), // left side
                 newSegment(4, 0, 2, 3) // right side
         );
@@ -219,8 +220,7 @@ void testSegmentsShareCommonPoint() {
     @Test
     void testSegmentsAtAngles() {
         // Segments at 45, 90, 135 degrees
-        List<Object> segments = List.of(
-                newSegment(0, 2, 4, 2), // horizontal
+        List<Object> segments = List.of(newSegment(0, 2, 4, 2), // horizontal
                 newSegment(2, 0, 2, 4), // vertical
                 newSegment(0, 0, 4, 4), // 45 degrees
                 newSegment(0, 4, 4, 0) // 135 degrees
@@ -261,8 +261,7 @@ void testPerformanceWithManySegments() {
     @Test
     void testIssueExample() {
         // Example from the GitHub issue
-        List<Object> segments = List.of(
-                newSegment(1, 1, 5, 5), // Segment A
+        List<Object> segments = List.of(newSegment(1, 1, 5, 5), // Segment A
                 newSegment(1, 5, 5, 1), // Segment B
                 newSegment(3, 0, 3, 6) // Segment C
         );
@@ -274,13 +273,64 @@ void testIssueExample() {
         assertTrue(containsPoint(intersections, 3.0, 3.0), "Intersection should be at (3, 3)");
     }
 
+    @Test
+    void testEventTypeOrdering() {
+        // Multiple events at the same point with different types
+        List<Object> segments = List.of(
+                newSegment(2, 2, 6, 2), // ends at (2,2)
+                newSegment(0, 2, 2, 2), // ends at (2,2)
+                newSegment(2, 2, 2, 6), // starts at (2,2)
+                newSegment(2, 0, 2, 2) // ends at (2,2)
+        );
+
+        Set<Point2D.Double> intersections = BentleyOttmann.findIntersections(cast(segments));
+        assertTrue(containsPoint(intersections, 2.0, 2.0));
+    }
+
+    @Test
+    void testCollinearOverlapWithInteriorPoint() {
+        // Test collinear segments where one segment's interior overlaps another
+        List<Object> segments = List.of(newSegment(0, 0, 6, 6), newSegment(2, 2, 4, 4));
+        Set<Point2D.Double> intersections = BentleyOttmann.findIntersections(cast(segments));
+
+        // Should find at least one overlap point (where segments touch/overlap)
+        assertFalse(intersections.isEmpty(), "Should find overlap points for collinear segments");
+        assertTrue(containsPoint(intersections, 2.0, 2.0) || containsPoint(intersections, 4.0, 4.0), "Should contain overlap boundary point");
+    }
+
+    @Test
+    void testCollinearTouchingAtBothEndpoints() {
+        // Test collinear segments that touch at both endpoints
+        // This triggers the "endpoint of both" logic (line 354-355)
+        List<Object> segments = List.of(newSegment(0, 0, 4, 4), newSegment(4, 4, 8, 8));
+
+        Set<Point2D.Double> intersections = BentleyOttmann.findIntersections(cast(segments));
+        assertEquals(1, intersections.size());
+        assertTrue(containsPoint(intersections, 4.0, 4.0), "Should find touching point");
+    }
+
+    @Test
+    void testCollinearOverlapPartialInterior() {
+        // Test case where segments overlap but one point is inside, one is endpoint
+        List<Object> segments = List.of(newSegment(0, 0, 5, 5), newSegment(3, 3, 7, 7));
+
+        Set<Point2D.Double> intersections = BentleyOttmann.findIntersections(cast(segments));
+
+        // Should detect the overlap region
+        assertFalse(intersections.isEmpty());
+        // The algorithm should return at least one of the boundary points
+        assertTrue(containsPoint(intersections, 3.0, 3.0) || containsPoint(intersections, 5.0, 5.0));
+    }
+
     private static Object newSegment(double x1, double y1, double x2, double y2) {
         return new BentleyOttmann.Segment(new Point2D.Double(x1, y1), new Point2D.Double(x2, y2));
     }
 
     private static List<BentleyOttmann.Segment> cast(List<Object> objs) {
         List<BentleyOttmann.Segment> result = new ArrayList<>();
-        for (Object o : objs) result.add((BentleyOttmann.Segment) o);
+        for (Object o : objs) {
+            result.add((BentleyOttmann.Segment) o);
+        }
         return result;
     }