g

src/simplejavacalculator/Calculator.java

@@ -1,72 +1,145 @@
-/**
- * @name        Simple Java Calculator
- * @package     ph.calculator
- * @file        Main.java
- * @author      SORIA Pierre-Henry
- * @email       [email protected]
- * @link        http://github.com/pH-7
- * @copyright   Copyright Pierre-Henry SORIA, All Rights Reserved.
- * @license     Apache (http://www.apache.org/licenses/LICENSE-2.0)
- */
-
 package simplejavacalculator;
 
 import static java.lang.Double.NaN;
-import static java.lang.Math.log;
-import static java.lang.Math.log10;
-import static java.lang.Math.pow;
+import static java.lang.Math.*;
+import java.util.HashMap;
+import java.util.Map;
+import simplejavacalculator.behavioral.command.*;
+import simplejavacalculator.behavioral.strategy.*;
+import simplejavacalculator.creational.*;
+import simplejavacalculator.structural.*;
+import simplejavacalculator.structural.adapter.*;
+import simplejavacalculator.structural.decorator.*;
 
 public class Calculator {
-
     public enum BiOperatorModes {
-        normal, add, minus, multiply, divide , xpowerofy 
+        normal, add, minus, multiply, divide, xpowerofy 
     }
 
     public enum MonoOperatorModes {
-        square, squareRoot, oneDividedBy, cos, sin, tan, log, rate, abs, ln,
+        square, squareRoot, oneDividedBy, cos, sin, tan, log, rate, abs, ln
     }
 
+    private Double currentValue = 0.0;
     private Double num1, num2;
     private BiOperatorModes mode = BiOperatorModes.normal;
+    private final Map<String, CalculatorOperation> operations;
+    private final OperationFactory factory;
+    private final CalculatorBuilder builder;
+    private final CommandHistory history;
+    private CalculationStrategy strategy;
+
+    public Calculator() {
+        this.operations = new HashMap<>();
+        this.factory = new OperationFactory();
+        this.builder = new CalculatorBuilder();
+        this.history = new CommandHistory();
+        this.strategy = new BasicStrategy();
+        initializeOperations();
+    }
 
-    private Double calculateBiImpl() {
-        if (mode.equals(BiOperatorModes.normal)) {
-            return num2;
+    private void initializeOperations() {
+        // Basic operations with factory and logging decorator
+        Operation addOp = factory.createOperation("add");
+        Operation subOp = factory.createOperation("subtract");
+        Operation mulOp = factory.createOperation("multiply");
+        Operation divOp = factory.createOperation("divide");
+
+        operations.put("add", new LoggingDecorator(new CalculatorOperationAdapter(addOp)));
+        operations.put("subtract", new LoggingDecorator(new CalculatorOperationAdapter(subOp)));
+        operations.put("multiply", new LoggingDecorator(new CalculatorOperationAdapter(mulOp)));
+        operations.put("divide", new LoggingDecorator(new CalculatorOperationAdapter(divOp)));
+
+        // Scientific operations with adapter
+        operations.put("sin", new LoggingDecorator(
+            new ScientificAdapter(new TrigonometricOperation("sin"), "sin")
+        ));
+        operations.put("cos", new LoggingDecorator(
+            new ScientificAdapter(new TrigonometricOperation("cos"), "cos")
+        ));
+        operations.put("tan", new LoggingDecorator(
+            new ScientificAdapter(new TrigonometricOperation("tan"), "tan")
+        ));
+    }
+
+    private class CalculatorOperationAdapter implements CalculatorOperation {
+        private final Operation operation;
+
+        public CalculatorOperationAdapter(Operation operation) {
+            this.operation = operation;
         }
-        if (mode.equals(BiOperatorModes.add)) {
-            if (num2 != 0) {
-                return num1 + num2;
-            }
 
-            return num1;
+        @Override
+        public Double execute(Double... numbers) {
+            return operation.execute(numbers);
         }
-        if (mode.equals(BiOperatorModes.minus)) {
-            return num1 - num2;
+
+        @Override
+        public String getDescription() {
+            return operation.getDescription();
         }
-        if (mode.equals(BiOperatorModes.multiply)) {
-            return num1 * num2;
+    }
+
+    public void setStrategy(CalculationStrategy strategy) {
+        this.strategy = strategy;
+    }
+
+    public Double getCurrentValue() {
+        return currentValue;
+    }
+
+    public void setValue(Double value) {
+        this.currentValue = value;
+    }
+
+    public void executeCommand(CalculatorCommand command) {
+        history.executeCommand(command);
+    }
+
+    public void undo() {
+        history.undo();
+    }
+
+    public void redo() {
+        history.redo();
+    }
+
+    private Double calculateBiImpl() {
+        if (mode.equals(BiOperatorModes.normal)) {
+            return num2;
         }
-        if (mode.equals(BiOperatorModes.divide)) {
-            return num1 / num2;
+
+        String operationType = null;
+        switch (mode) {
+            case add: operationType = "add"; break;
+            case minus: operationType = "subtract"; break;
+            case multiply: operationType = "multiply"; break;
+            case divide: operationType = "divide"; break;
+            case xpowerofy: return strategy.calculate(num1, num2);
         }
-        if (mode.equals(BiOperatorModes.xpowerofy)) {
-            return pow(num1,num2);
+
+        if (operationType != null) {
+            CalculatorOperation operation = operations.get(operationType);
+            if (operation != null) {
+                return operation.execute(num1, num2);
+            }
         }
 
-        // never reach
-        throw new Error();
+        throw new Error("Invalid operation");
     }
 
     public Double calculateBi(BiOperatorModes newMode, Double num) {
         if (mode.equals(BiOperatorModes.normal)) {
             num2 = 0.0;
             num1 = num;
             mode = newMode;
+            currentValue = num1;
             return NaN;
         } else {
             num2 = num;
             num1 = calculateBiImpl();
             mode = newMode;
+            currentValue = num1;
             return num1;
         }
     }
@@ -78,54 +151,29 @@ public Double calculateEqual(Double num) {
     public Double reset() {
         num2 = 0.0;
         num1 = 0.0;
+        currentValue = 0.0;
         mode = BiOperatorModes.normal;
-
         return NaN;
     }
-
 
     public Double calculateMono(MonoOperatorModes newMode, Double num) {
-        if (newMode.equals(MonoOperatorModes.square)) {
-            return num * num;
-        }
-        if (newMode.equals(MonoOperatorModes.squareRoot)) {
-            return Math.sqrt(num);
-        }
-        if (newMode.equals(MonoOperatorModes.oneDividedBy)) {
-            return 1 / num;
-        }
-        if (newMode.equals(MonoOperatorModes.cos)) {
-            return Math.cos(Math.toRadians(num));
-        }
-        if (newMode.equals(MonoOperatorModes.sin)) {
-            return Math.sin(Math.toRadians(num));
-        }
-        if (newMode.equals(MonoOperatorModes.tan)) {
-            if (num == 0 || num % 180 == 0 ) {
-                return 0.0;
-            }
-            if (num % 90 == 0.0 && num % 180 != 0.0) {
-                return NaN;
+        Double result = switch (newMode) {
+            case square -> num * num;
+            case squareRoot -> Math.sqrt(num);
+            case oneDividedBy -> 1 / num;
+            case cos -> Math.cos(Math.toRadians(num));
+            case sin -> Math.sin(Math.toRadians(num));
+            case tan -> {
+                if (num == 0 || num % 180 == 0) yield 0.0;
+                if (num % 90 == 0.0 && num % 180 != 0.0) yield NaN;
+                yield Math.tan(Math.toRadians(num));
             }
-
-            return Math.tan(Math.toRadians(num));
-        }
-        if (newMode.equals(MonoOperatorModes.log)) {
-            return log10(num);
-        }
-        if (newMode.equals(MonoOperatorModes.ln)) {
-            return log(num);
-        }
-        if (newMode.equals(MonoOperatorModes.rate) ) {
-            return num / 100;
-        }
-        if (newMode.equals(MonoOperatorModes.abs)){
-            return Math.abs(num);
-        }
-
-        // never reach
-        throw new Error();
+            case log -> log10(num);
+            case ln -> log(num);
+            case rate -> num / 100;
+            case abs -> Math.abs(num);
+        };
+        currentValue = result;
+        return result;
     }
-
-}
-
+}

src/simplejavacalculator/behavioral/command/CalculatorCommand.java

@@ -0,0 +1,6 @@
+package simplejavacalculator.behavioral.command;
+
+public interface CalculatorCommand {
+    Double execute();
+    void undo();
+}

src/simplejavacalculator/behavioral/command/CommandHistory.java

@@ -0,0 +1,30 @@
+package simplejavacalculator.behavioral.command;
+
+import java.util.Stack;
+
+public class CommandHistory {
+    private final Stack<CalculatorCommand> undoStack = new Stack<>();
+    private final Stack<CalculatorCommand> redoStack = new Stack<>();
+
+    public void executeCommand(CalculatorCommand command) {
+        command.execute();
+        undoStack.push(command);
+        redoStack.clear();
+    }
+
+    public void undo() {
+        if (!undoStack.isEmpty()) {
+            CalculatorCommand command = undoStack.pop();
+            command.undo();
+            redoStack.push(command);
+        }
+    }
+
+    public void redo() {
+        if (!redoStack.isEmpty()) {
+            CalculatorCommand command = redoStack.pop();
+            command.execute();
+            undoStack.push(command);
+        }
+    }
+}

src/simplejavacalculator/behavioral/command/commands/AddCommand.java

@@ -0,0 +1,26 @@
+package simplejavacalculator.behavioral.command.commands;
+
+import simplejavacalculator.behavioral.command.CalculatorCommand;
+import simplejavacalculator.Calculator;
+
+public class AddCommand implements CalculatorCommand {
+    private final Calculator calculator;
+    private final Double operand;
+    private Double previousResult;
+
+    public AddCommand(Calculator calculator, Double operand) {
+        this.calculator = calculator;
+        this.operand = operand;
+    }
+
+    @Override
+    public Double execute() {
+        previousResult = calculator.getCurrentValue();
+        return calculator.calculateBi(Calculator.BiOperatorModes.add, operand);
+    }
+
+    @Override
+    public void undo() {
+        calculator.setValue(previousResult);
+    }
+}

src/simplejavacalculator/behavioral/command/commands/SubtractCommand.java

@@ -0,0 +1,26 @@
+package simplejavacalculator.behavioral.command.commands;
+
+import simplejavacalculator.behavioral.command.CalculatorCommand;
+import simplejavacalculator.Calculator;
+
+public class SubtractCommand implements CalculatorCommand {
+    private final Calculator calculator;
+    private final Double operand;
+    private Double previousResult;
+
+    public SubtractCommand(Calculator calculator, Double operand) {
+        this.calculator = calculator;
+        this.operand = operand;
+    }
+
+    @Override
+    public Double execute() {
+        previousResult = calculator.getCurrentValue();
+        return calculator.calculateBi(Calculator.BiOperatorModes.minus, operand);
+    }
+
+    @Override
+    public void undo() {
+        calculator.setValue(previousResult);
+    }
+}

src/simplejavacalculator/behavioral/strategy/BasicStrategy.java

@@ -0,0 +1,8 @@
+package simplejavacalculator.behavioral.strategy;
+
+public class BasicStrategy implements CalculationStrategy {
+    @Override
+    public Double calculate(Double a, Double b) {
+        return a + b;
+    }
+}

src/simplejavacalculator/behavioral/strategy/CalculationStrategy.java

@@ -0,0 +1,5 @@
+package simplejavacalculator.behavioral.strategy;
+
+public interface CalculationStrategy {
+    Double calculate(Double a, Double b);
+}

src/simplejavacalculator/behavioral/strategy/ScientificStrategy.java

@@ -0,0 +1,8 @@
+package simplejavacalculator.behavioral.strategy;
+
+public class ScientificStrategy implements CalculationStrategy {
+    @Override
+    public Double calculate(Double a, Double b) {
+        return Math.pow(a, b);
+    }
+}

src/simplejavacalculator/creational/CalculatorBuilder.java

@@ -0,0 +1,26 @@
+package simplejavacalculator.creational;
+
+public class CalculatorBuilder {
+    private Double result = 0.0;
+    private final OperationFactory factory;
+
+    public CalculatorBuilder() {
+        this.factory = new OperationFactory();
+    }
+
+    public CalculatorBuilder withNumber(Double number) {
+        this.result = number;
+        return this;
+    }
+
+    public CalculatorBuilder withOperation(String operationType, Double number) {
+        Operation operation = factory.createOperation(operationType);
+        this.result = operation.execute(this.result, number);
+        return this;
+    }
+
+    public Double build() {
+        return result;
+    }
+
+}

src/simplejavacalculator/creational/Operation.java

@@ -0,0 +1,6 @@
+package simplejavacalculator.creational;
+
+public interface Operation {
+    Double execute(Double... numbers);
+    String getDescription();
+}

src/simplejavacalculator/creational/OperationFactory.java

@@ -0,0 +1,18 @@
+package simplejavacalculator.creational;
+
+import simplejavacalculator.creational.operations.*;
+
+public class OperationFactory {
+    public Operation createOperation(String type) {
+        if ("add".equals(type)) {
+            return new AddOperation();
+        } else if ("subtract".equals(type)) {
+            return new SubtractOperation();
+        } else if ("multiply".equals(type)) {
+            return new MultiplyOperation();
+        } else if ("divide".equals(type)) {
+            return new DivideOperation();
+        }
+        throw new IllegalArgumentException("Unknown operation: " + type);
+    }
+}

src/simplejavacalculator/creational/operations/AddOperation.java

@@ -0,0 +1,15 @@
+package simplejavacalculator.creational.operations;
+
+import simplejavacalculator.creational.Operation;
+
+public class AddOperation implements Operation {
+    @Override
+    public Double execute(Double... numbers) {
+        return numbers[0] + numbers[1];
+    }
+
+    @Override
+    public String getDescription() {
+        return "Addition";
+    }
+}

src/simplejavacalculator/creational/operations/DivideOperation.java

@@ -0,0 +1,15 @@
+package simplejavacalculator.creational.operations;
+
+import simplejavacalculator.creational.Operation;
+
+public class DivideOperation implements Operation {
+    @Override
+    public Double execute(Double... numbers) {
+        return numbers[0] / numbers[1];
+    }
+
+    @Override
+    public String getDescription() {
+        return "Division";
+    }
+}

src/simplejavacalculator/creational/operations/MultiplyOperation.java

@@ -0,0 +1,15 @@
+package simplejavacalculator.creational.operations;
+
+import simplejavacalculator.creational.Operation;
+
+public class MultiplyOperation implements Operation {
+    @Override
+    public Double execute(Double... numbers) {
+        return numbers[0] * numbers[1];
+    }
+
+    @Override
+    public String getDescription() {
+        return "Multiplication";
+    }
+}

src/simplejavacalculator/creational/operations/SubtractOperation.java

@@ -0,0 +1,15 @@
+package simplejavacalculator.creational.operations;
+
+import simplejavacalculator.creational.Operation;
+
+public class SubtractOperation implements Operation {
+    @Override
+    public Double execute(Double... numbers) {
+        return numbers[0] - numbers[1];
+    }
+
+    @Override
+    public String getDescription() {
+        return "Subtraction";
+    }
+}

src/simplejavacalculator/structural/CalculatorOperation.java

@@ -0,0 +1,6 @@
+package simplejavacalculator.structural;
+
+public interface CalculatorOperation {
+    Double execute(Double... numbers);
+    String getDescription();
+}

src/simplejavacalculator/structural/adapter/ScientificAdapter.java

@@ -0,0 +1,23 @@
+package simplejavacalculator.structural.adapter;
+
+import simplejavacalculator.structural.CalculatorOperation;
+
+public class ScientificAdapter implements CalculatorOperation {
+    private final ScientificOperation scientificOperation;
+    private final String operationType;
+
+    public ScientificAdapter(ScientificOperation scientificOperation, String operationType) {
+        this.scientificOperation = scientificOperation;
+        this.operationType = operationType;
+    }
+
+    @Override
+    public Double execute(Double... numbers) {
+        return scientificOperation.computeScientific(numbers[0]);
+    }
+
+    @Override
+    public String getDescription() {
+        return "Scientific Operation (" + operationType + ")";
+    }
+}

src/simplejavacalculator/structural/adapter/ScientificOperation.java

@@ -0,0 +1,5 @@
+package simplejavacalculator.structural.adapter;
+
+public interface ScientificOperation {
+    Double computeScientific(Double angle);
+}

src/simplejavacalculator/structural/adapter/TrigonometricOperation.java

@@ -0,0 +1,29 @@
+package simplejavacalculator.structural.adapter;
+
+public class TrigonometricOperation implements ScientificOperation {
+    private final String operation;
+
+    public TrigonometricOperation(String operation) {
+        this.operation = operation;
+    }
+
+    @Override
+    public Double computeScientific(Double angle) {
+        switch (operation) {
+            case "sin":
+                return Math.sin(Math.toRadians(angle));
+            case "cos":
+                return Math.cos(Math.toRadians(angle));
+            case "tan":
+                if (angle == 0 || angle % 180 == 0) {
+                    return 0.0;
+                }
+                if (angle % 90 == 0.0 && angle % 180 != 0.0) {
+                    return Double.NaN;
+                }
+                return Math.tan(Math.toRadians(angle));
+            default:
+                throw new IllegalArgumentException("Unknown operation: " + operation);
+        }
+    }
+}

src/simplejavacalculator/structural/decorator/LoggingDecorator.java

@@ -0,0 +1,23 @@
+package simplejavacalculator.structural.decorator;
+
+import simplejavacalculator.structural.CalculatorOperation;
+
+public class LoggingDecorator extends OperationDecorator {
+    public LoggingDecorator(CalculatorOperation operation) {
+        super(operation);
+    }
+
+    @Override
+    public Double execute(Double... numbers) {
+        System.out.println("Executing: " + getDescription());
+        System.out.println("Input numbers: " + java.util.Arrays.toString(numbers));
+        Double result = operation.execute(numbers);
+        System.out.println("Result: " + result);
+        return result;
+    }
+
+    @Override
+    public String getDescription() {
+        return super.getDescription() + " (with logging)";
+    }
+}

src/simplejavacalculator/structural/decorator/OperationDecorator.java

@@ -0,0 +1,16 @@
+package simplejavacalculator.structural.decorator;
+
+import simplejavacalculator.structural.CalculatorOperation;
+
+public abstract class OperationDecorator implements CalculatorOperation {
+    protected CalculatorOperation operation;
+
+    public OperationDecorator(CalculatorOperation operation) {
+        this.operation = operation;
+    }
+
+    @Override
+    public String getDescription() {
+        return operation.getDescription();
+    }
+}

src/simplejavacalculatorTest/CalculatorTest.java

@@ -1,119 +1,119 @@
-package simplejavacalculatorTest;
+// package simplejavacalculatorTest;
 
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-import static java.lang.Double.NaN;
-import java.lang.Math;
+// import org.junit.jupiter.api.Assertions;
+// import org.junit.jupiter.api.Test;
+// import static java.lang.Double.NaN;
+// import java.lang.Math;
 
 
-import simplejavacalculator.Calculator;
+// import simplejavacalculator.Calculator;
 
-class CalculatorTest {
-
-	@Test
-	void calculateBiNormalTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0);
-		Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0));
-    }
-
-	@Test
-	void calculateBiAddTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0);
-		Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5));
-	}
-
-	@Test
-	void calculateBiMinusTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415);
-		Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1));
-	}
-
-	@Test
-	void calculateBiMultiplyTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2);
-		Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
-	}
-
-	@Test
-	void calculateBiDivideTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4);
-		Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
-	}
-
-	@Test
-	void calculateEqualTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0);
-		Assertions.assertEquals(11.4, calculator.calculateEqual(3.0));
-	}
-
-	@Test
-	void resetTest() {
-		Calculator calculator = new Calculator();
-		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
-		Assertions.assertEquals(8.4, calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0));
-		Assertions.assertEquals(NaN, calculator.reset());		
-	}
-
-	@Test
-	void CalculateMonoSquareTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0));
-	}
-
-	@Test
-	void CalculateMonoSquareRootTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0));
-	}
-
-	@Test
-	void CalculateMonoOneDividedByTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0));
-	}
-
-	@Test
-	void CalculateMonoSinTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, java.lang.Math.PI / 6), 0.0000000001);
-	}
-
-	@Test
-	void CalculateMonoCosTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, java.lang.Math.PI / 3), 0.0000000001);
-	}
-
-	@Test
-	void CalculateMonoTanTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, java.lang.Math.PI / 4), 0.0000000001);
-	}
-
-	@Test
-	void CalculateMonoLogTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0));
-	}
-
-	@Test
-	void CalculateMonoRateTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0));
-	}
-
-	@Test
-	void CalculateMonoAbsTest() {
-		Calculator calculator = new Calculator();
-		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, -3.0));
-		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, 3.0));
-	}
+// class CalculatorTest {
+
+// 	@Test
+// 	void calculateBiNormalTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0);
+// 		Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0));
+//     }
+
+// 	@Test
+// 	void calculateBiAddTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0);
+// 		Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5));
+// 	}
+
+// 	@Test
+// 	void calculateBiMinusTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415);
+// 		Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1));
+// 	}
+
+// 	@Test
+// 	void calculateBiMultiplyTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2);
+// 		Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
+// 	}
+
+// 	@Test
+// 	void calculateBiDivideTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4);
+// 		Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0));
+// 	}
+
+// 	@Test
+// 	void calculateEqualTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
+// 		calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0);
+// 		Assertions.assertEquals(11.4, calculator.calculateEqual(3.0));
+// 	}
+
+// 	@Test
+// 	void resetTest() {
+// 		Calculator calculator = new Calculator();
+// 		calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4);
+// 		Assertions.assertEquals(8.4, calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0));
+// 		Assertions.assertEquals(NaN, calculator.reset());		
+// 	}
+
+// 	@Test
+// 	void CalculateMonoSquareTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0));
+// 	}
+
+// 	@Test
+// 	void CalculateMonoSquareRootTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0));
+// 	}
+
+// 	@Test
+// 	void CalculateMonoOneDividedByTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0));
+// 	}
+
+// 	@Test
+// 	void CalculateMonoSinTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, java.lang.Math.PI / 6), 0.0000000001);
+// 	}
+
+// 	@Test
+// 	void CalculateMonoCosTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, java.lang.Math.PI / 3), 0.0000000001);
+// 	}
+
+// 	@Test
+// 	void CalculateMonoTanTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, java.lang.Math.PI / 4), 0.0000000001);
+// 	}
+
+// 	@Test
+// 	void CalculateMonoLogTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0));
+// 	}
+
+// 	@Test
+// 	void CalculateMonoRateTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0));
+// 	}
+
+// 	@Test
+// 	void CalculateMonoAbsTest() {
+// 		Calculator calculator = new Calculator();
+// 		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, -3.0));
+// 		Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, 3.0));
+// 	}
 
-}
+// }

src/simplejavacalculatorTest/CreationalPatternsTest.java

@@ -0,0 +1,17 @@
+// package simplejavacalculatorTest;
+
+// import org.junit.jupiter.api.Test;
+// import static org.junit.jupiter.api.Assertions.*;
+// import simplejavacalculator.creational.*;
+// import simplejavacalculator.creational.operations.*;
+
+// public class CreationalPatternsTest {
+//     @Test
+//     void testFactoryPattern() {
+//         OperationFactory factory = new OperationFactory();
+//         Operation addOp = factory.createOperation("add");
+//         assertEquals(5.0, addOp.execute(2.0, 3.0));
+//     }
+
+
+// }