From 55e5cbeb0fa891191916d7a4b8e9ab9367e37e09 Mon Sep 17 00:00:00 2001
From: Pit Friedrich <friedrich@depag.de>
Date: Sat, 25 Jul 2026 20:09:19 +0200
Subject: [PATCH] feat: add CalcFunctionFactory for calculator operations (#13)

Callers pick an operation via the CalcOperation enum instead of
instantiating implementation classes directly.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .../java/com/example/LoopTestApplication.java | 21 +++-----
 .../com/example/util/CalcFunctionFactory.java | 20 +++++++
 .../java/com/example/util/CalcOperation.java  | 10 ++++
 .../example/util/CalcFunctionFactoryTest.java | 53 +++++++++++++++++++
 4 files changed, 89 insertions(+), 15 deletions(-)
 create mode 100644 src/main/java/com/example/util/CalcFunctionFactory.java
 create mode 100644 src/main/java/com/example/util/CalcOperation.java
 create mode 100644 src/test/java/com/example/util/CalcFunctionFactoryTest.java

diff --git a/src/main/java/com/example/LoopTestApplication.java b/src/main/java/com/example/LoopTestApplication.java
index 0c9c4bc..6eefa67 100644
--- a/src/main/java/com/example/LoopTestApplication.java
+++ b/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.MultiplyFunction;
-import com.example.util.PowerFunction;
-import com.example.util.SubtractFunction;
+import com.example.util.CalcFunctionFactory;
+import com.example.util.CalcOperation;
 
 public class LoopTestApplication {
 
     static void main() {
         System.out.println("============== Calculator =============");
-        CalcFunction add = new AddFunction();
-        System.out.println("ADDITION: " + add.calc(2, 5, 6));
-        CalcFunction subtract = new SubtractFunction();
-        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));
+        for (CalcOperation operation : CalcOperation.values()) {
+            CalcFunction function = CalcFunctionFactory.create(operation);
+            System.out.println(operation + ": " + function.calc(2, 5, 6));
+        }
     }
 }
diff --git a/src/main/java/com/example/util/CalcFunctionFactory.java b/src/main/java/com/example/util/CalcFunctionFactory.java
new file mode 100644
index 0000000..7d4638d
--- /dev/null
+++ b/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();
+        };
+    }
+}
diff --git a/src/main/java/com/example/util/CalcOperation.java b/src/main/java/com/example/util/CalcOperation.java
new file mode 100644
index 0000000..21ea60e
--- /dev/null
+++ b/src/main/java/com/example/util/CalcOperation.java
@@ -0,0 +1,10 @@
+package com.example.util;
+
+public enum CalcOperation {
+
+    ADD,
+    SUBTRACT,
+    MULTIPLY,
+    DIVIDE,
+    POWER
+}
diff --git a/src/test/java/com/example/util/CalcFunctionFactoryTest.java b/src/test/java/com/example/util/CalcFunctionFactoryTest.java
new file mode 100644
index 0000000..b862517
--- /dev/null
+++ b/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));
+    }
+}