fix: add mock tests for edge cases

Author: saahilmahato

src/main/java/com/thealgorithms/maths/Prime/EulerPseudoprime.java

@@ -45,7 +45,9 @@ public static boolean isProbablePrime(BigInteger n, int trials) {
         for (int i = 0; i < trials; i++) {
             BigInteger a = uniformRandom(BigInteger.TWO, n.subtract(BigInteger.TWO));
             BigInteger jacobi = BigInteger.valueOf(jacobiSymbol(a, n));
-            if (jacobi.equals(BigInteger.ZERO)) return false;
+            if (jacobi.equals(BigInteger.ZERO)) {
+                return false;
+            }
 
             BigInteger exp = n.subtract(BigInteger.ONE).divide(BigInteger.TWO);
             BigInteger modExp = a.modPow(exp, n);
@@ -58,22 +60,11 @@ public static boolean isProbablePrime(BigInteger n, int trials) {
         return true; // probably prime
     }
 
-    /**
-     * Generates a random BigInteger between {@code min} and {@code max}, inclusive.
-     */
-    private static BigInteger uniformRandom(BigInteger min, BigInteger max) {
-        BigInteger result;
-        do {
-            result = new BigInteger(max.bitLength(), random);
-        } while (result.compareTo(min) < 0 || result.compareTo(max) > 0);
-        return result;
-    }
-
     /**
      * Computes the Jacobi symbol (a/n).
      * Assumes n is positive and odd.
      */
-    private static int jacobiSymbol(BigInteger a, BigInteger n) {
+    public static int jacobiSymbol(BigInteger a, BigInteger n) {
         if (n.signum() <= 0 || n.mod(BigInteger.TWO).equals(BigInteger.ZERO)) {
             throw new IllegalArgumentException("n must be positive and odd.");
         }
@@ -103,4 +94,15 @@ private static int jacobiSymbol(BigInteger a, BigInteger n) {
 
         return n.equals(BigInteger.ONE) ? result : 0;
     }
+
+    /**
+     * Generates a random BigInteger between {@code min} and {@code max}, inclusive.
+     */
+    private static BigInteger uniformRandom(BigInteger min, BigInteger max) {
+        BigInteger result;
+        do {
+            result = new BigInteger(max.bitLength(), random);
+        } while (result.compareTo(min) < 0 || result.compareTo(max) > 0);
+        return result;
+    }
 }

src/test/java/com/thealgorithms/maths/prime/EulerPseudoprimeTest.java

@@ -1,10 +1,13 @@
 package com.thealgorithms.maths.prime;
 
 import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
 
 import com.thealgorithms.maths.Prime.EulerPseudoprime;
 import java.math.BigInteger;
 import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
 
 class EulerPseudoprimeTest {
 
@@ -75,8 +78,54 @@ void testUniformRandomRange() throws Exception {
     }
 
     @Test
-    void testCompositeWithZeroJacobiSymbol() {
-        // Choose n = 9, a = 3 → jacobi(3,9) = 0 should make it return false early
-        assertFalse(EulerPseudoprime.isProbablePrime(BigInteger.valueOf(9), 1));
+    void testIsProbablePrimeWhenJacobiSymbolIsZero() {
+        try (MockedStatic<EulerPseudoprime> mockedPrimality = Mockito.mockStatic(EulerPseudoprime.class, Mockito.CALLS_REAL_METHODS)) {
+
+            // Mock jacobiSymbol to return 0 to test the branch
+            mockedPrimality.when(() -> EulerPseudoprime.jacobiSymbol(any(BigInteger.class), any(BigInteger.class))).thenReturn(0);
+
+            boolean result = EulerPseudoprime.isProbablePrime(BigInteger.valueOf(15), 1);
+
+            assertFalse(result);
+        }
+    }
+
+    @Test
+    void testJacobiSymbolThrowsForEvenOrNonPositiveN() throws Exception {
+        var method = EulerPseudoprime.class.getDeclaredMethod("jacobiSymbol", BigInteger.class, BigInteger.class);
+        method.setAccessible(true);
+
+        // Helper lambda to unwrap InvocationTargetException
+        Runnable invokeJacobi = () -> {
+            try {
+                method.invoke(null, BigInteger.valueOf(2), BigInteger.valueOf(8));
+            } catch (Exception e) {
+                // unwrap
+                Throwable cause = e.getCause();
+                if (cause instanceof IllegalArgumentException) {
+                    throw (IllegalArgumentException) cause;
+                } else {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+
+        // Now check that it actually throws
+        assertThrows(IllegalArgumentException.class, invokeJacobi::run);
+
+        // Another case: non-positive n
+        Runnable invokeJacobi2 = () -> {
+            try {
+                method.invoke(null, BigInteger.valueOf(5), BigInteger.valueOf(-3));
+            } catch (Exception e) {
+                Throwable cause = e.getCause();
+                if (cause instanceof IllegalArgumentException) {
+                    throw (IllegalArgumentException) cause;
+                } else {
+                    throw new RuntimeException(e);
+                }
+            }
+        };
+        assertThrows(IllegalArgumentException.class, invokeJacobi2::run);
     }
 }