refactor: cleanup EulersFunction (#5388)

src/main/java/com/thealgorithms/others/EulersFunction.java

@@ -1,12 +1,19 @@
 package com.thealgorithms.others;
 
 /**
- * @brief utility class for <a href="https://en.wikipedia.org/wiki/Euler%27s_totient_function">Euler's totient function</a>
+ * Utility class for computing
+ * <a href="https://en.wikipedia.org/wiki/Euler%27s_totient_function">Euler's totient function</a>.
  */
 public final class EulersFunction {
     private EulersFunction() {
     }
 
+    /**
+     * Validates that the input is a positive integer.
+     *
+     * @param n the input number to validate
+     * @throws IllegalArgumentException if {@code n} is non-positive
+     */
     private static void checkInput(int n) {
         if (n <= 0) {
             throw new IllegalArgumentException("n must be positive.");
@@ -14,11 +21,12 @@ public final class EulersFunction {
     }
 
     /**
-     * @brief computes the value of Euler's totient function for given input
+     * Computes the value of Euler's totient function for a given input.
-     * @details has time complexity of O(sqrt(n))
+     * This function has a time complexity of O(sqrt(n)).
-     * @param n the input
+     *
-     * @exception IllegalArgumentException n is non-positive
+     * @param n the input number
-     * @return the value of Euler's totient function for the input
+     * @return the value of Euler's totient function for the given input
+     * @throws IllegalArgumentException if {@code n} is non-positive
      */
     public static int getEuler(int n) {
         checkInput(n);

src/test/java/com/thealgorithms/others/EulersFunctionTest.java

@@ -3,37 +3,31 @@ package com.thealgorithms.others;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import java.util.HashMap;
+import java.util.stream.Stream;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 class EulersFunctionTest {
-    @Test
-    public void testGetEuler() {
-        HashMap<Integer, Integer> testCases = new HashMap<>();
-        testCases.put(1, 1);
-        testCases.put(2, 1);
-        testCases.put(3, 2);
-        testCases.put(4, 2);
-        testCases.put(5, 4);
-        testCases.put(6, 2);
-        testCases.put(10, 4);
-        testCases.put(21, 12);
-        testCases.put(69, 44);
-        testCases.put(47, 46);
-        testCases.put(46, 22);
-        testCases.put(55, 40);
-        testCases.put(34, 16);
-        testCases.put(20, 8);
-        testCases.put(20, 8);
-        testCases.put(1024, 512);
 
-        for (final var tc : testCases.entrySet()) {
+    @ParameterizedTest
-            assertEquals(tc.getValue(), EulersFunction.getEuler(tc.getKey()));
+    @MethodSource("provideNumbersForGetEuler")
-        }
+    void testGetEuler(int input, int expected) {
+        assertEquals(expected, EulersFunction.getEuler(input));
     }
 
-    @Test
+    @ParameterizedTest
-    public void testGetEulerThrowsExceptionForNonPositiveInput() {
+    @MethodSource("provideInvalidNumbersForGetEuler")
-        assertThrows(IllegalArgumentException.class, () -> EulersFunction.getEuler(0));
+    void testGetEulerThrowsExceptionForNonPositiveInput(int input) {
+        assertThrows(IllegalArgumentException.class, () -> EulersFunction.getEuler(input));
+    }
+
+    private static Stream<Arguments> provideNumbersForGetEuler() {
+        return Stream.of(Arguments.of(1, 1), Arguments.of(2, 1), Arguments.of(3, 2), Arguments.of(4, 2), Arguments.of(5, 4), Arguments.of(6, 2), Arguments.of(10, 4), Arguments.of(21, 12), Arguments.of(69, 44), Arguments.of(47, 46), Arguments.of(46, 22), Arguments.of(55, 40), Arguments.of(34, 16),
+            Arguments.of(20, 8), Arguments.of(1024, 512));
+    }
+
+    private static Stream<Arguments> provideInvalidNumbersForGetEuler() {
+        return Stream.of(Arguments.of(0), Arguments.of(-1), Arguments.of(-10));
     }
 }