Merge pull request 'feat: add CalcFunctionFactory for calculator operations (#13)' (#14) from ai/issue-13 into main

Reviewed-on: #14

src/main/java/com/example/LoopTestApplication.java

@@ -1,25 +1,16 @@
 package com.example;
 
-import com.example.util.AddFunction;
 import com.example.util.CalcFunction;
-import com.example.util.DivideFunction;
+import com.example.util.CalcFunctionFactory;
-import com.example.util.MultiplyFunction;
+import com.example.util.CalcOperation;
-import com.example.util.PowerFunction;
-import com.example.util.SubtractFunction;
 
 public class LoopTestApplication {
 
     static void main() {
         System.out.println("============== Calculator =============");
-        CalcFunction add = new AddFunction();
+        for (CalcOperation operation : CalcOperation.values()) {
-        System.out.println("ADDITION: " + add.calc(2, 5, 6));
+            CalcFunction function = CalcFunctionFactory.create(operation);
-        CalcFunction subtract = new SubtractFunction();
+            System.out.println(operation + ": " + function.calc(2, 5, 6));
-        System.out.println("SUBTRACTION: " + subtract.calc(2, 5, 6));
+        }
-        CalcFunction multiply = new MultiplyFunction();
-        System.out.println("MULTIPLICATION: " + multiply.calc(2, 5, 6));
-        CalcFunction divide = new DivideFunction();
-        System.out.println("DIVISION: " + divide.calc(2, 5, 6));
-        CalcFunction power = new PowerFunction();
-        System.out.println("POWER: " + power.calc(2, 5, 6));
     }
 }

src/main/java/com/example/util/CalcFunctionFactory.java

@@ -0,0 +1,20 @@
+package com.example.util;
+
+public final class CalcFunctionFactory {
+
+    private CalcFunctionFactory() {
+    }
+
+    public static CalcFunction create(CalcOperation operation) {
+        if (operation == null) {
+            throw new IllegalArgumentException("Operation must not be null");
+        }
+        return switch (operation) {
+            case ADD -> new AddFunction();
+            case SUBTRACT -> new SubtractFunction();
+            case MULTIPLY -> new MultiplyFunction();
+            case DIVIDE -> new DivideFunction();
+            case POWER -> new PowerFunction();
+        };
+    }
+}

src/main/java/com/example/util/CalcOperation.java

@@ -0,0 +1,10 @@
+package com.example.util;
+
+public enum CalcOperation {
+
+    ADD,
+    SUBTRACT,
+    MULTIPLY,
+    DIVIDE,
+    POWER
+}

src/test/java/com/example/util/CalcFunctionFactoryTest.java

@@ -0,0 +1,53 @@
+package com.example.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class CalcFunctionFactoryTest {
+
+    @Test
+    void createsAddFunction() {
+        assertInstanceOf(AddFunction.class, CalcFunctionFactory.create(CalcOperation.ADD));
+    }
+
+    @Test
+    void createsSubtractFunction() {
+        assertInstanceOf(SubtractFunction.class, CalcFunctionFactory.create(CalcOperation.SUBTRACT));
+    }
+
+    @Test
+    void createsMultiplyFunction() {
+        assertInstanceOf(MultiplyFunction.class, CalcFunctionFactory.create(CalcOperation.MULTIPLY));
+    }
+
+    @Test
+    void createsDivideFunction() {
+        assertInstanceOf(DivideFunction.class, CalcFunctionFactory.create(CalcOperation.DIVIDE));
+    }
+
+    @Test
+    void createsPowerFunction() {
+        assertInstanceOf(PowerFunction.class, CalcFunctionFactory.create(CalcOperation.POWER));
+    }
+
+    @Test
+    void createsFunctionForEveryOperation() {
+        for (CalcOperation operation : CalcOperation.values()) {
+            assertNotNull(CalcFunctionFactory.create(operation), "No function for " + operation);
+        }
+    }
+
+    @Test
+    void createdFunctionCalculates() {
+        assertEquals(13.0, CalcFunctionFactory.create(CalcOperation.ADD).calc(2.0, 5.0, 6.0));
+    }
+
+    @Test
+    void rejectsNullOperation() {
+        assertThrows(IllegalArgumentException.class, () -> CalcFunctionFactory.create(null));
+    }
+}