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

Author: Microindole

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

@@ -168,10 +168,30 @@ private static List<Point> sortCounterClockwise(List<Point> hullPoints) {
             return -crossProduct;
         });
 
-        // Build result with pivot first
+        // Build result with pivot first, filtering out intermediate collinear points
         List<Point> result = new ArrayList<>();
         result.add(finalPivot);
-        result.addAll(sorted);
+
+        if (!sorted.isEmpty()) {
+            // This loop iterates through the points sorted by angle.
+            // For points that are collinear with the pivot, we only want the one that is farthest away.
+            // The sort places closer points first.
+            for (int i = 0; i < sorted.size() - 1; i++) {
+                // Check the orientation of the pivot, the current point, and the next point.
+                int orientation = Point.orientation(finalPivot, sorted.get(i), sorted.get(i + 1));
+
+                // If the orientation is not 0, it means the next point (i+1) is at a new angle.
+                // Therefore, the current point (i) must be the farthest point at its angle. We keep it.
+                if (orientation != 0) {
+                    result.add(sorted.get(i));
+                }
+                // If the orientation is 0, the points are collinear. We discard the current point (i)
+                // because it is closer to the pivot than the next point (i+1).
+            }
+            // Always add the very last point from the sorted list. It is either the only point
+            // at its angle, or it's the farthest among a set of collinear points.
+            result.add(sorted.getLast());
+        }
 
         return result;
     }

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

@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import org.junit.jupiter.api.Test;
@@ -46,62 +47,35 @@ void testConvexHullRecursive() {
         // Test 3: Complex polygon
         // Convex hull vertices in CCW order from bottom-most point (2,-4):
         // (2,-4) -> (3,0) -> (3,3) -> (0,3) -> (0,0) -> (1,-3) -> back to (2,-4)
-        points = Arrays.asList(
-                new Point(0, 3), new Point(2, 2), new Point(1, 1),
-                new Point(2, 1), new Point(3, 0), new Point(0, 0),
-                new Point(3, 3), new Point(2, -1), new Point(2, -4),
-                new Point(1, -3)
-        );
+        points = Arrays.asList(new Point(0, 3), new Point(2, 2), new Point(1, 1), new Point(2, 1), new Point(3, 0), new Point(0, 0), new Point(3, 3), new Point(2, -1), new Point(2, -4), new Point(1, -3));
         result = ConvexHull.convexHullRecursive(points);
-        expected = Arrays.asList(
-                new Point(2, -4),  // Bottom-most, left-most (starting point)
-                new Point(3, 0),   // Right side going up
-                new Point(3, 3),   // Top right corner
-                new Point(0, 3),   // Top left corner
-                new Point(0, 0),   // Left side coming down
-                new Point(1, -3)   // Bottom section, back towards start
-        );
+        expected = Arrays.asList(new Point(2, -4), new Point(3, 0), new Point(3, 3), new Point(0, 3), new Point(0, 0), new Point(1, -3));
         assertEquals(expected, result);
         assertTrue(isCounterClockwise(result), "Points should be in counter-clockwise order");
     }
 
     @Test
     void testConvexHullRecursiveAdditionalCases() {
         // Test 4: Square (all corners on hull)
-        List<Point> points = Arrays.asList(
-                new Point(0, 0), new Point(2, 0),
-                new Point(2, 2), new Point(0, 2)
-        );
+        List<Point> points = Arrays.asList(new Point(0, 0), new Point(2, 0), new Point(2, 2), new Point(0, 2));
         List<Point> result = ConvexHull.convexHullRecursive(points);
-        List<Point> expected = Arrays.asList(
-                new Point(0, 0), new Point(2, 0),
-                new Point(2, 2), new Point(0, 2)
-        );
+        List<Point> expected = Arrays.asList(new Point(0, 0), new Point(2, 0), new Point(2, 2), new Point(0, 2));
         assertEquals(expected, result);
         assertTrue(isCounterClockwise(result), "Square points should be in CCW order");
 
         // Test 5: Pentagon with interior point
-        points = Arrays.asList(
-                new Point(0, 0), new Point(4, 0), new Point(5, 3),
-                new Point(2, 5), new Point(-1, 3), new Point(2, 2) // (2,2) is interior
+        points = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(5, 3), new Point(2, 5), new Point(-1, 3), new Point(2, 2) // (2,2) is interior
         );
         result = ConvexHull.convexHullRecursive(points);
         // CCW from (0,0): (0,0) -> (4,0) -> (5,3) -> (2,5) -> (-1,3)
-        expected = Arrays.asList(
-                new Point(0, 0), new Point(4, 0), new Point(5, 3),
-                new Point(2, 5), new Point(-1, 3)
-        );
+        expected = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(5, 3), new Point(2, 5), new Point(-1, 3));
         assertEquals(expected, result);
         assertTrue(isCounterClockwise(result), "Pentagon points should be in CCW order");
 
         // Test 6: Simple triangle (clearly convex)
-        points = Arrays.asList(
-                new Point(0, 0), new Point(4, 0), new Point(2, 3)
-        );
+        points = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(2, 3));
         result = ConvexHull.convexHullRecursive(points);
-        expected = Arrays.asList(
-                new Point(0, 0), new Point(4, 0), new Point(2, 3)
-        );
+        expected = Arrays.asList(new Point(0, 0), new Point(4, 0), new Point(2, 3));
         assertEquals(expected, result);
         assertTrue(isCounterClockwise(result), "Triangle points should be in CCW order");
     }
@@ -124,4 +98,41 @@ private boolean isCounterClockwise(List<Point> points) {
 
         return signedArea > 0; // Positive signed area means counter-clockwise
     }
+
+    @Test
+    void testRecursiveHullForCoverage() {
+        // 1. Test the base cases of the convexHullRecursive method (covering scenarios with < 3 input points).
+
+        // Test Case: 0 points
+        List<Point> pointsEmpty = new ArrayList<>();
+        List<Point> resultEmpty = ConvexHull.convexHullRecursive(pointsEmpty);
+        assertTrue(resultEmpty.isEmpty(), "Should return an empty list for an empty input list");
+
+        // Test Case: 1 point
+        List<Point> pointsOne = List.of(new Point(5, 5));
+        // Pass a new ArrayList because the original method modifies the input list.
+        List<Point> resultOne = ConvexHull.convexHullRecursive(new ArrayList<>(pointsOne));
+        List<Point> expectedOne = List.of(new Point(5, 5));
+        assertEquals(expectedOne, resultOne, "Should return the single point for a single-point input");
+
+        // Test Case: 2 points
+        List<Point> pointsTwo = Arrays.asList(new Point(10, 1), new Point(0, 0));
+        List<Point> resultTwo = ConvexHull.convexHullRecursive(new ArrayList<>(pointsTwo));
+        List<Point> expectedTwo = Arrays.asList(new Point(0, 0), new Point(10, 1)); // Should return the two points, sorted.
+        assertEquals(expectedTwo, resultTwo, "Should return the two sorted points for a two-point input");
+
+        // 2. Test the logic for handling collinear points in the sortCounterClockwise method.
+
+        // Construct a scenario where multiple collinear points lie on an edge of the convex hull.
+        // The expected convex hull vertices are (0,0), (10,0), and (5,5).
+        // When (0,0) is used as the pivot for polar angle sorting, (5,0) and (10,0) are collinear.
+        // This will trigger the crossProduct == 0 branch in the sortCounterClockwise method.
+        List<Point> pointsWithCollinearOnHull = Arrays.asList(new Point(0, 0), new Point(5, 0), new Point(10, 0), new Point(5, 5), new Point(2, 2));
+
+        List<Point> resultCollinear = ConvexHull.convexHullRecursive(new ArrayList<>(pointsWithCollinearOnHull));
+        List<Point> expectedCollinear = Arrays.asList(new Point(0, 0), new Point(10, 0), new Point(5, 5));
+
+        assertEquals(expectedCollinear, resultCollinear, "Should correctly handle collinear points on the hull edge");
+        assertTrue(isCounterClockwise(resultCollinear), "The result of the collinear test should be in counter-clockwise order");
+    }
 }