From 36063334e32e462e234a4c308e3cea4fe42fee50 Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:05:20 +0200
Subject: [PATCH 1/9] =?UTF-8?q?Gr=C3=BCner=20Test?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/htw/berlin/prog2/ha1/CalculatorTest.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index ddff0daf..ace3ed26 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -90,5 +90,20 @@ void testMultipleDecimalDots() {
 
 
     //TODO hier weitere Tests erstellen
+    @Test
+    @DisplayName("Soll eine Zahl von einer anderen Abziehen")
+    void testSubtract() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("-");
+        calc.pressDigitKey(1);
+
+        String expected = "1";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
 }
 

From 821fd4cdc20a2d766b5518318cbbf3b23990b58e Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:11:10 +0200
Subject: [PATCH 2/9] =?UTF-8?q?Gr=C3=BCner=20Test=20-=2002?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index ace3ed26..bd2658d3 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -98,6 +98,7 @@ void testSubtract() {
         calc.pressDigitKey(2);
         calc.pressBinaryOperationKey("-");
         calc.pressDigitKey(1);
+        calc.pressEqualsKey();
 
         String expected = "1";
         String actual = calc.readScreen();

From 06e2de559b016402a4292bd1a91e311ee8bb7244 Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 22 Apr 2024 09:16:11 +0200
Subject: [PATCH 3/9] erster Roter Fehler

---
 .../htw/berlin/prog2/ha1/CalculatorTest.java   | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index bd2658d3..ea0cc5d5 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -106,5 +106,23 @@ void testSubtract() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    @DisplayName("Soll mehrere Zahlen von einander Abziehen und Multiplizieren")
+    void testSubtractAndMultiply() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("-");
+        calc.pressDigitKey(1);
+        calc.pressBinaryOperationKey("x");
+        calc.pressDigitKey(4);
+        calc.pressEqualsKey();
+
+        String expected = "-2";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
 }
 

From a1f43c20a668954127fc5abbfe71abff1540c81f Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 22 Apr 2024 22:50:45 +0200
Subject: [PATCH 4/9] zweiter roter Fehler

---
 .../htw/berlin/prog2/ha1/CalculatorTest.java  | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index ea0cc5d5..9f0e5ccb 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -107,7 +107,7 @@ void testSubtract() {
     }
 
     @Test
-    @DisplayName("Soll mehrere Zahlen von einander Abziehen und Multiplizieren")
+    @DisplayName("Soll mehr als nur zwei Zahlen zusammenrechnen.")
     void testSubtractAndMultiply() {
         Calculator calc = new Calculator();
 
@@ -124,5 +124,22 @@ void testSubtractAndMultiply() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    @DisplayName("Soll ")
+    void newTest() {
+        Calculator calc = new Calculator();
+
+        calc.pressNegativeKey();
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("-");
+        calc.pressDigitKey(3);
+        calc.pressEqualsKey();
+
+        String expected = "1";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
 }
 

From 5b40e9b9eac5817f57f96b37299cf4fb5399279a Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 22 Apr 2024 23:35:40 +0200
Subject: [PATCH 5/9] Fehler 1 geloest

---
 .../java/htw/berlin/prog2/ha1/Calculator.java | 72 +++++++++++++------
 .../htw/berlin/prog2/ha1/CalculatorTest.java  |  6 +-
 2 files changed, 55 insertions(+), 23 deletions(-)

diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
index 84c04f21..ce4003b9 100644
--- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
+++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
@@ -14,6 +14,12 @@ public class Calculator {
 
     private String latestOperation = "";
 
+    private double[] saveLastValues = new double[15];
+    private String[] saveLastOperation = new String[15];
+
+    private int sLVIndex  = 0;
+    private int sLOIndex  = 0;
+
     /**
      * @return den aktuellen Bildschirminhalt als String
      */
@@ -30,9 +36,7 @@ public String readScreen() {
      */
     public void pressDigitKey(int digit) {
         if(digit > 9 || digit < 0) throw new IllegalArgumentException();
-
-        if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = "";
-
+        if(screen.equals("0") || Double.parseDouble(screen) == 0) screen = "";
         screen = screen + digit;
     }
 
@@ -60,8 +64,11 @@ public void pressClearKey() {
      * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division
      */
     public void pressBinaryOperationKey(String operation)  {
-        latestValue = Double.parseDouble(screen);
-        latestOperation = operation;
+        saveLastValues[sLVIndex++] = Double.parseDouble(screen);
+        saveLastOperation[sLOIndex++] = operation;
+        screen = "0";
+        // latestValue = Double.parseDouble(screen);
+        // latestOperation = operation;
     }
 
     /**
@@ -74,16 +81,16 @@ public void pressBinaryOperationKey(String operation)  {
     public void pressUnaryOperationKey(String operation) {
         latestValue = Double.parseDouble(screen);
         latestOperation = operation;
-        var result = switch(operation) {
-            case "√" -> Math.sqrt(Double.parseDouble(screen));
-            case "%" -> Double.parseDouble(screen) / 100;
-            case "1/x" -> 1 / Double.parseDouble(screen);
+        double result = 0.0;
+        switch(operation) {
+            case "√" -> result = Math.sqrt(Double.parseDouble(screen));
+            case "%" -> result = Double.parseDouble(screen) / 100;
+            case "1/x" -> result = 1 / Double.parseDouble(screen);
             default -> throw new IllegalArgumentException();
         };
         screen = Double.toString(result);
         if(screen.equals("NaN")) screen = "Error";
         if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10);
-
     }
 
     /**
@@ -117,17 +124,40 @@ public void pressNegativeKey() {
      * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt
      * und das Ergebnis direkt angezeigt.
      */
+    public double checkOperation() {
+        double result = saveLastValues[0];
+        for(int i = 0; i < sLOIndex; i++){
+            String operation = saveLastOperation[i];
+            double nextValue = saveLastValues[i+1];
+            switch(operation) {
+                case "+": result += nextValue;
+                break;
+                case "-": result -= nextValue;
+                break;
+                case "/": result /= nextValue;
+                if (nextValue == 0) throw new ArithmeticException("Division by zero");
+                break;
+                case "x": result *= nextValue;
+                break;
+                default: throw new IllegalArgumentException();
+            }
+        }
+        if(result % 1 == 0){
+            return (int) result;
+        }else {
+            return result;
+        }
+    }
+
     public void pressEqualsKey() {
-        var result = switch(latestOperation) {
-            case "+" -> latestValue + Double.parseDouble(screen);
-            case "-" -> latestValue - Double.parseDouble(screen);
-            case "x" -> latestValue * Double.parseDouble(screen);
-            case "/" -> latestValue / Double.parseDouble(screen);
-            default -> throw new IllegalArgumentException();
-        };
+        saveLastValues[sLVIndex++] = Double.parseDouble(screen);
+        double result = checkOperation();
         screen = Double.toString(result);
-        if(screen.equals("Infinity")) screen = "Error";
-        if(screen.endsWith(".0")) screen = screen.substring(0,screen.length()-2);
-        if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10);
+        if(result % 1 == 0){
+           screen = Integer.toString((int) result);
+        }else {
+           screen = Double.toString(result);
+        }
+        if (screen.equals("Infinity")) screen = "Error";
     }
-}
+}
\ No newline at end of file
diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index 9f0e5ccb..b667ef79 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -114,11 +114,13 @@ void testSubtractAndMultiply() {
         calc.pressDigitKey(2);
         calc.pressBinaryOperationKey("-");
         calc.pressDigitKey(1);
-        calc.pressBinaryOperationKey("x");
+        calc.pressBinaryOperationKey("+");
         calc.pressDigitKey(4);
+        calc.pressBinaryOperationKey("+");
+        calc.pressDigitKey(6);
         calc.pressEqualsKey();
 
-        String expected = "-2";
+        String expected = "11";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);

From 22f96b13e4dca215f328427b2e62c09e57059d6d Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Tue, 23 Apr 2024 12:07:53 +0200
Subject: [PATCH 6/9] Fehler Punkt vor Strich gefunden

---
 .../java/htw/berlin/prog2/ha1/CalculatorTest.java    | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index b667ef79..5680b966 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -117,27 +117,29 @@ void testSubtractAndMultiply() {
         calc.pressBinaryOperationKey("+");
         calc.pressDigitKey(4);
         calc.pressBinaryOperationKey("+");
-        calc.pressDigitKey(6);
+        calc.pressDigitKey(4);
         calc.pressEqualsKey();
 
-        String expected = "11";
+        String expected = "9";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
     }
 
     @Test
-    @DisplayName("Soll ")
+    @DisplayName("Soll punkt vor Strich ausrechnen")
     void newTest() {
         Calculator calc = new Calculator();
 
         calc.pressNegativeKey();
-        calc.pressDigitKey(2);
+        calc.pressDigitKey(9);
         calc.pressBinaryOperationKey("-");
         calc.pressDigitKey(3);
+        calc.pressBinaryOperationKey("x");
+        calc.pressDigitKey(2);
         calc.pressEqualsKey();
 
-        String expected = "1";
+        String expected = "3";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);

From c26337af686fa97193b4825c339bfb59bbecf104 Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Tue, 23 Apr 2024 13:12:49 +0200
Subject: [PATCH 7/9] =?UTF-8?q?Mehrere=20Zahlen=20k=C3=B6nnen=20zusammen?=
 =?UTF-8?q?=20gerechnet=20werden=20-=20mit=20Zus=C3=A4tzlicher=20Ausgabe?=
 =?UTF-8?q?=20der=20Erwarteten=20und=20Tats=C3=A4chlichen=20Ergebnisse?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../java/htw/berlin/prog2/ha1/Calculator.java | 54 +++++++++----------
 .../htw/berlin/prog2/ha1/CalculatorTest.java  |  3 +-
 2 files changed, 26 insertions(+), 31 deletions(-)

diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
index ce4003b9..ca85040b 100644
--- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
+++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
@@ -1,4 +1,6 @@
 package htw.berlin.prog2.ha1;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Eine Klasse, die das Verhalten des Online Taschenrechners imitiert, welcher auf
@@ -14,11 +16,8 @@ public class Calculator {
 
     private String latestOperation = "";
 
-    private double[] saveLastValues = new double[15];
-    private String[] saveLastOperation = new String[15];
-
-    private int sLVIndex  = 0;
-    private int sLOIndex  = 0;
+    private ArrayList<Double> saveLastValues = new ArrayList<>();
+    private ArrayList<String> saveLastOperation = new ArrayList<>();
 
     /**
      * @return den aktuellen Bildschirminhalt als String
@@ -64,11 +63,9 @@ public void pressClearKey() {
      * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division
      */
     public void pressBinaryOperationKey(String operation)  {
-        saveLastValues[sLVIndex++] = Double.parseDouble(screen);
-        saveLastOperation[sLOIndex++] = operation;
+        saveLastValues.add(Double.parseDouble(screen));
+        saveLastOperation.add(operation);
         screen = "0";
-        // latestValue = Double.parseDouble(screen);
-        // latestOperation = operation;
     }
 
     /**
@@ -124,11 +121,24 @@ public void pressNegativeKey() {
      * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt
      * und das Ergebnis direkt angezeigt.
      */
+
+    public void pressEqualsKey() {
+        saveLastValues.add(Double.parseDouble(screen));
+        double result = checkOperation();
+        if(result % 1 == 0){
+            screen = Integer.toString((int) result);
+        }else {
+            screen = Double.toString(result);
+        }
+        if (screen.equals("Infinity")) screen = "Error";
+
+
+
     public double checkOperation() {
-        double result = saveLastValues[0];
-        for(int i = 0; i < sLOIndex; i++){
-            String operation = saveLastOperation[i];
-            double nextValue = saveLastValues[i+1];
+        double result = saveLastValues.get(0);
+        for(int i = 0; i < saveLastOperation.size(); i++){
+            String operation = saveLastOperation.get(i);
+            double nextValue = saveLastValues.get(i+1);
             switch(operation) {
                 case "+": result += nextValue;
                 break;
@@ -142,22 +152,6 @@ public double checkOperation() {
                 default: throw new IllegalArgumentException();
             }
         }
-        if(result % 1 == 0){
-            return (int) result;
-        }else {
-            return result;
-        }
-    }
-
-    public void pressEqualsKey() {
-        saveLastValues[sLVIndex++] = Double.parseDouble(screen);
-        double result = checkOperation();
-        screen = Double.toString(result);
-        if(result % 1 == 0){
-           screen = Integer.toString((int) result);
-        }else {
-           screen = Double.toString(result);
-        }
-        if (screen.equals("Infinity")) screen = "Error";
+        return result;
     }
 }
\ No newline at end of file
diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index 5680b966..ed6ac180 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -122,8 +122,9 @@ void testSubtractAndMultiply() {
 
         String expected = "9";
         String actual = calc.readScreen();
-
         assertEquals(expected, actual);
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test

From 84179f806e1483109e51378b35a7a6d868798a18 Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Fri, 26 Apr 2024 10:01:12 +0200
Subject: [PATCH 8/9] Punkt vor Strich fehler korrigiert

---
 .../java/htw/berlin/prog2/ha1/Calculator.java | 62 ++++++++++++-------
 .../htw/berlin/prog2/ha1/CalculatorTest.java  | 11 ++--
 2 files changed, 48 insertions(+), 25 deletions(-)

diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
index ca85040b..ccdfb6b4 100644
--- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
+++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
@@ -28,7 +28,7 @@ public String readScreen() {
 
     /**
      * Empfängt den Wert einer gedrückten Zifferntaste. Da man nur eine Taste auf einmal
-     * drücken kann muss der Wert positiv und einstellig sein und zwischen 0 und 9 liegen.
+     * drücken kann, muss der Wert positiv und einstellig sein und zwischen 0 und 9 liegen.
      * Führt in jedem Fall dazu, dass die gerade gedrückte Ziffer auf dem Bildschirm angezeigt
      * oder rechts an die zuvor gedrückte Ziffer angehängt angezeigt wird.
      * @param digit Die Ziffer, deren Taste gedrückt wurde
@@ -41,10 +41,10 @@ public void pressDigitKey(int digit) {
 
     /**
      * Empfängt den Befehl der C- bzw. CE-Taste (Clear bzw. Clear Entry).
-     * Einmaliges Drücken der Taste löscht die zuvor eingegebenen Ziffern auf dem Bildschirm
-     * so dass "0" angezeigt wird, jedoch ohne zuvor zwischengespeicherte Werte zu löschen.
+     * Einmaliges Drücken der Taste löscht die zuvor eingegebenen Ziffern auf dem Bildschirm,
+     * sodass "0" angezeigt wird, jedoch ohne zuvor zwischengespeicherte Werte zu löschen.
      * Wird daraufhin noch einmal die Taste gedrückt, dann werden auch zwischengespeicherte
-     * Werte sowie der aktuelle Operationsmodus zurückgesetzt, so dass der Rechner wieder
+     * Werte sowie der aktuelle Operationsmodus zurückgesetzt, sodass der Rechner wieder
      * im Ursprungszustand ist.
      */
     public void pressClearKey() {
@@ -55,12 +55,12 @@ public void pressClearKey() {
 
     /**
      * Empfängt den Wert einer gedrückten binären Operationstaste, also eine der vier Operationen
-     * Addition, Substraktion, Division, oder Multiplikation, welche zwei Operanden benötigen.
+     * Addition, Subtraktion, Division, oder Multiplikation, welche zwei Operanden benötigen.
      * Beim ersten Drücken der Taste wird der Bildschirminhalt nicht verändert, sondern nur der
      * Rechner in den passenden Operationsmodus versetzt.
      * Beim zweiten Drücken nach Eingabe einer weiteren Zahl wird direkt des aktuelle Zwischenergebnis
      * auf dem Bildschirm angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt.
-     * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division
+     * @param operation "+" für Addition, "-" für Subtraktion, "x" für Multiplikation, "/" für Division
      */
     public void pressBinaryOperationKey(String operation)  {
         saveLastValues.add(Double.parseDouble(screen));
@@ -131,25 +131,45 @@ public void pressEqualsKey() {
             screen = Double.toString(result);
         }
         if (screen.equals("Infinity")) screen = "Error";
+    }
 
 
+    public double checkOperation() { //2 Durchgänge - 1. Erledigt alle "Punkt"(multiplikation/division) Aufgaben
+        List<Double> zwischenWert = new ArrayList<>();
+        List<String> restOperationen = new ArrayList<>();
 
-    public double checkOperation() {
-        double result = saveLastValues.get(0);
-        for(int i = 0; i < saveLastOperation.size(); i++){
+        double aktWert = saveLastValues.get(0);
+        for (int i = 0; i < saveLastOperation.size(); i++) {
             String operation = saveLastOperation.get(i);
-            double nextValue = saveLastValues.get(i+1);
-            switch(operation) {
-                case "+": result += nextValue;
-                break;
-                case "-": result -= nextValue;
-                break;
-                case "/": result /= nextValue;
-                if (nextValue == 0) throw new ArithmeticException("Division by zero");
-                break;
-                case "x": result *= nextValue;
-                break;
-                default: throw new IllegalArgumentException();
+            double nextWert = saveLastValues.get(i + 1);
+
+            switch (operation) {
+                case "x":
+                    aktWert *= nextWert;
+                    break;
+                case "/":
+                    if (nextWert == 0) throw new ArithmeticException("Division durch null!");
+                    aktWert /= nextWert;
+                    break;
+                default:
+                    zwischenWert.add(aktWert);
+                    restOperationen.add(operation);
+                    aktWert = nextWert;
+                    break;
+            }
+        }
+        zwischenWert.add(aktWert);
+
+        double result = zwischenWert.get(0); // 2. Durchgang - Erledigt alle "Strich"(Addition/Subtraktion) Aufgaben
+        for (int i = 0; i < restOperationen.size(); i++) {
+            String operation = restOperationen.get(i);
+            double nextWert = zwischenWert.get(i + 1);
+            if (operation.equals("+")) {
+                result += nextWert;
+            } else if (operation.equals("-")) {
+                result -= nextWert;
+            } else {
+                throw new IllegalArgumentException("Falsche Operation");
             }
         }
         return result;
diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index ed6ac180..698dcb74 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -129,21 +129,24 @@ void testSubtractAndMultiply() {
 
     @Test
     @DisplayName("Soll punkt vor Strich ausrechnen")
-    void newTest() {
+    void punktVorStrichTest() {
         Calculator calc = new Calculator();
 
         calc.pressNegativeKey();
-        calc.pressDigitKey(9);
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(0);
         calc.pressBinaryOperationKey("-");
         calc.pressDigitKey(3);
         calc.pressBinaryOperationKey("x");
-        calc.pressDigitKey(2);
+        calc.pressDigitKey(4);
         calc.pressEqualsKey();
 
-        String expected = "3";
+        String expected = "8";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
 }

From f6b8d797dd6173758a5d336ee5ff4f743c38fff4 Mon Sep 17 00:00:00 2001
From: coladude <153623352+coladude@users.noreply.github.com>
Date: Mon, 6 May 2024 19:51:04 +0200
Subject: [PATCH 9/9] Division durch 0 fehler behoben

---
 .../java/htw/berlin/prog2/ha1/Calculator.java | 22 ++++++++++++-------
 .../htw/berlin/prog2/ha1/CalculatorTest.java  | 20 +++++++++++++++++
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
index ccdfb6b4..e133725e 100644
--- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
+++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
@@ -124,13 +124,18 @@ public void pressNegativeKey() {
 
     public void pressEqualsKey() {
         saveLastValues.add(Double.parseDouble(screen));
-        double result = checkOperation();
-        if(result % 1 == 0){
-            screen = Integer.toString((int) result);
-        }else {
-            screen = Double.toString(result);
+        double result;
+        try {
+            result = checkOperation();
+            if (result % 1 == 0) {
+                screen = Integer.toString((int) result);
+            } else {
+                screen = Double.toString(result);
+            }
+            //if (screen.equals("Infinity") || screen.equals("NaN")) {screen = "Error";}
+        }catch (ArithmeticException e) {
+            screen = "Error";
         }
-        if (screen.equals("Infinity")) screen = "Error";
     }
 
 
@@ -148,8 +153,9 @@ public double checkOperation() { //2 Durchgänge - 1. Erledigt alle "Punkt"(mult
                     aktWert *= nextWert;
                     break;
                 case "/":
-                    if (nextWert == 0) throw new ArithmeticException("Division durch null!");
-                    aktWert /= nextWert;
+                    if (nextWert == 0) {
+                        throw new ArithmeticException("Division durch null!");
+                    }else{aktWert /= nextWert;}
                     break;
                 default:
                     zwischenWert.add(aktWert);
diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
index 698dcb74..1a0fe5e2 100644
--- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
+++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
@@ -24,6 +24,9 @@ void testPositiveAddition() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testPositiveAddition()");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test
@@ -38,6 +41,9 @@ void testSquareRoot() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testSquareRoot()");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test
@@ -54,6 +60,9 @@ void testDivisionByZero() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testDivisionByZero");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test
@@ -69,6 +78,9 @@ void testSquareRootOfNegative() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testSquareRootOfNegative()");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test
@@ -86,6 +98,9 @@ void testMultipleDecimalDots() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testMultipleDecimalDots");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
 
@@ -104,6 +119,9 @@ void testSubtract() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("testSubtract()");
+        System.out.println("Ausgerechnetes Ergebnis: " + actual);
+        System.out.println("Erwartetes Ergebnis: " + expected);
     }
 
     @Test
@@ -123,6 +141,7 @@ void testSubtractAndMultiply() {
         String expected = "9";
         String actual = calc.readScreen();
         assertEquals(expected, actual);
+        System.out.println("testSubtractAndMultiply()");
         System.out.println("Ausgerechnetes Ergebnis: " + actual);
         System.out.println("Erwartetes Ergebnis: " + expected);
     }
@@ -145,6 +164,7 @@ void punktVorStrichTest() {
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
+        System.out.println("punktVorStrichTest()");
         System.out.println("Ausgerechnetes Ergebnis: " + actual);
         System.out.println("Erwartetes Ergebnis: " + expected);
     }