fix: reject negative input in SumOfSquares and add tests

Author: lieutenant-Rohit

src/main/java/com/thealgorithms/maths/SumOfSquares.java

@@ -5,7 +5,6 @@
  * Find minimum number of perfect squares that sum to given number
  *
  * @see <a href="https://en.wikipedia.org/wiki/Lagrange%27s_four-square_theorem">Lagrange's Four Square Theorem</a>
- * @author BEASTSHRIRAM
  */
 public final class SumOfSquares {
 
@@ -16,10 +15,15 @@ private SumOfSquares() {
     /**
      * Find minimum number of perfect squares that sum to n
      *
-     * @param n the target number
+     * @param n the target number (must be non-negative)
      * @return minimum number of squares needed
+     * @throws IllegalArgumentException if n is negative
      */
     public static int minSquares(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative");
+        }
+
         if (isPerfectSquare(n)) {
             return 1;
         }
@@ -51,3 +55,4 @@ private static boolean isPerfectSquare(int n) {
         return root * root == n;
     }
 }
+

src/test/java/com/thealgorithms/maths/SumOfSquaresTest.java

@@ -1,41 +1,40 @@
 package com.thealgorithms.maths;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
 /**
  * Test class for SumOfSquares
- *
- * @author BEASTSHRIRAM
  */
 class SumOfSquaresTest {
 
     @Test
     void testPerfectSquares() {
         // Perfect squares should return 1
-        assertEquals(1, SumOfSquares.minSquares(1)); // 1^2
-        assertEquals(1, SumOfSquares.minSquares(4)); // 2^2
-        assertEquals(1, SumOfSquares.minSquares(9)); // 3^2
+        assertEquals(1, SumOfSquares.minSquares(1));  // 1^2
+        assertEquals(1, SumOfSquares.minSquares(4));  // 2^2
+        assertEquals(1, SumOfSquares.minSquares(9));  // 3^2
         assertEquals(1, SumOfSquares.minSquares(16)); // 4^2
         assertEquals(1, SumOfSquares.minSquares(25)); // 5^2
     }
 
     @Test
     void testTwoSquares() {
         // Numbers that can be expressed as sum of two squares
-        assertEquals(2, SumOfSquares.minSquares(2)); // 1^2 + 1^2
-        assertEquals(2, SumOfSquares.minSquares(5)); // 1^2 + 2^2
-        assertEquals(2, SumOfSquares.minSquares(8)); // 2^2 + 2^2
+        assertEquals(2, SumOfSquares.minSquares(2));  // 1^2 + 1^2
+        assertEquals(2, SumOfSquares.minSquares(5));  // 1^2 + 2^2
+        assertEquals(2, SumOfSquares.minSquares(8));  // 2^2 + 2^2
         assertEquals(2, SumOfSquares.minSquares(10)); // 1^2 + 3^2
         assertEquals(2, SumOfSquares.minSquares(13)); // 2^2 + 3^2
     }
 
     @Test
     void testThreeSquares() {
         // Numbers that require exactly three squares
-        assertEquals(3, SumOfSquares.minSquares(3)); // 1^2 + 1^2 + 1^2
-        assertEquals(3, SumOfSquares.minSquares(6)); // 1^2 + 1^2 + 2^2
+        assertEquals(3, SumOfSquares.minSquares(3));  // 1^2 + 1^2 + 1^2
+        assertEquals(3, SumOfSquares.minSquares(6));  // 1^2 + 1^2 + 2^2
         assertEquals(3, SumOfSquares.minSquares(11)); // 1^2 + 1^2 + 3^2
         assertEquals(3, SumOfSquares.minSquares(12)); // 2^2 + 2^2 + 2^2
         assertEquals(3, SumOfSquares.minSquares(14)); // 1^2 + 2^2 + 3^2
@@ -44,7 +43,7 @@ void testThreeSquares() {
     @Test
     void testFourSquares() {
         // Numbers that require exactly four squares (form 4^a * (8b + 7))
-        assertEquals(4, SumOfSquares.minSquares(7)); // 1^2 + 1^2 + 1^2 + 2^2
+        assertEquals(4, SumOfSquares.minSquares(7));  // 1^2 + 1^2 + 1^2 + 2^2
         assertEquals(4, SumOfSquares.minSquares(15)); // 1^2 + 1^2 + 2^2 + 3^2
         assertEquals(4, SumOfSquares.minSquares(23)); // 1^2 + 1^2 + 3^2 + 3^2
         assertEquals(4, SumOfSquares.minSquares(28)); // 4 * 7, so needs 4 squares
@@ -55,14 +54,22 @@ void testFourSquares() {
     void testLargerNumbers() {
         // Test some larger numbers
         assertEquals(1, SumOfSquares.minSquares(100)); // 10^2
-        assertEquals(2, SumOfSquares.minSquares(65)); // 1^2 + 8^2
-        assertEquals(3, SumOfSquares.minSquares(19)); // 1^2 + 3^2 + 3^2
-        assertEquals(4, SumOfSquares.minSquares(60)); // 4 * 15, and 15 = 8*1 + 7
+        assertEquals(2, SumOfSquares.minSquares(65));  // 1^2 + 8^2
+        assertEquals(3, SumOfSquares.minSquares(19));  // 1^2 + 3^2 + 3^2
+        assertEquals(4, SumOfSquares.minSquares(60));  // 4 * 15, and 15 = 8*1 + 7
     }
 
     @Test
     void testEdgeCases() {
         // Test edge case
         assertEquals(1, SumOfSquares.minSquares(0)); // 0^2
     }
+
+    @Test
+    void testNegativeInput() {
+        // Negative inputs should throw IllegalArgumentException
+        assertThrows(IllegalArgumentException.class, () -> SumOfSquares.minSquares(-1));
+        assertThrows(IllegalArgumentException.class, () -> SumOfSquares.minSquares(-10));
+    }
 }
+