From eb0a39025e5082fbe56295b023a6030a062fed87 Mon Sep 17 00:00:00 2001 From: Jannick Date: Tue, 21 Oct 2025 12:27:47 +0200 Subject: [PATCH 1/5] teilaufgabe 1 --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 54 ++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index ddff0da..660c44e 100644 --- a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -88,7 +88,59 @@ void testMultipleDecimalDots() { assertEquals(expected, actual); } + @Test + @DisplayName("should display result after adding two positive multi-digit numbers") + void testAdditionWithNegatives() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(2); + calc.pressDigitKey(0); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(2); + calc.pressDigitKey(0); + calc.pressEqualsKey(); + + String expected = "40"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should display result after dividing two positiv numbers") + void testPositiveDivision() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(2); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String expected = "1"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + @Test + @DisplayName("should display result after dividing two positive single-digit numbers") + void testDivision() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(6); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String expected = "3"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + + + + //TODO hier weitere Tests erstellen } - From 6d2d69fb415be1c1f3d34281a83656231254f063 Mon Sep 17 00:00:00 2001 From: Jannick Date: Tue, 21 Oct 2025 12:55:28 +0200 Subject: [PATCH 2/5] teilaufgabe 2 --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index 660c44e..e5327e9 100644 --- a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -136,6 +136,49 @@ void testDivision() { assertEquals(expected, actual); } + @Test + @DisplayName("should display result after dividing two negativ multi digit numbers") + void testNegativDivisionWithHighNumbers() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressDigitKey(6); + calc.pressDigitKey(7); + calc.pressDigitKey(8); + calc.pressNegativeKey(); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(1); + calc.pressDigitKey(2); + calc.pressDigitKey(3); + calc.pressDigitKey(4); + calc.pressEqualsKey(); + + String expected = "-4.6"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + @Test + @DisplayName("should display result after multiplicating two positiv multi digit numbers") + void testMultiplicationWithHighNumbers() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(1); + calc.pressDigitKey(2); + calc.pressDigitKey(3); + calc.pressDigitKey(4); + calc.pressBinaryOperationKey("*"); + calc.pressDigitKey(1); + calc.pressDigitKey(2); + calc.pressDigitKey(3); + calc.pressDigitKey(4); + calc.pressEqualsKey(); + + String expected = "1522756"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } From 9ebab035b1bea787ee8f2389c9c3337bb171464d Mon Sep 17 00:00:00 2001 From: Jannick Date: Tue, 21 Oct 2025 13:02:49 +0200 Subject: [PATCH 3/5] teilaufgabe 2 korrigiert --- src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index e5327e9..feb535d 100644 --- a/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -167,14 +167,16 @@ void testMultiplicationWithHighNumbers() { calc.pressDigitKey(2); calc.pressDigitKey(3); calc.pressDigitKey(4); - calc.pressBinaryOperationKey("*"); + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("x"); calc.pressDigitKey(1); calc.pressDigitKey(2); calc.pressDigitKey(3); calc.pressDigitKey(4); + calc.pressDigitKey(5); calc.pressEqualsKey(); - String expected = "1522756"; + String expected = "152399025"; String actual = calc.readScreen(); assertEquals(expected, actual); From bb6257df49f994b74ad53bf9a427fc664f22391a Mon Sep 17 00:00:00 2001 From: Jannick Date: Tue, 21 Oct 2025 13:30:14 +0200 Subject: [PATCH 4/5] teilaufgabe 3 erster bug fix --- .../java/htw/berlin/prog2/ha1/Calculator.java | 44 ++++++++++++++++--- 1 file changed, 39 insertions(+), 5 deletions(-) diff --git a/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/src/main/java/htw/berlin/prog2/ha1/Calculator.java index 84c04f2..ae0e4de 100644 --- a/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -117,17 +117,51 @@ public void pressNegativeKey() { * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt * und das Ergebnis direkt angezeigt. */ + /** + * Empfängt den Befehl der gedrückten "="-Taste. + * Führt die zuvor gespeicherte Rechenoperation (z. B. +, -, x, /) mit dem aktuell eingegebenen + * Wert auf dem Bildschirm aus und zeigt das Ergebnis an. + * + * In dieser Version wurde die Art geändert, wie das Ergebnis in Textform (also auf dem Bildschirm) + * angezeigt wird: + * + * - Früher wurde das Ergebnis einfach mit Double.toString(result) umgewandelt. + * Das führte dazu, dass sehr große oder sehr kleine Zahlen in wissenschaftlicher + * Notation angezeigt wurden (z. B. "1.52399025E8" statt "152399025"). + * + * - Jetzt wird das Ergebnis mit BigDecimal formatiert. Dadurch wird die Zahl immer + * "normal" dargestellt, also so wie man sie auf einem Taschenrechner erwarten würde. + * + * - Außerdem wird jetzt überprüft, ob das Ergebnis "NaN" (keine Zahl) oder "Infinity" + * (z. B. bei Division durch 0) ist. In diesen Fällen zeigt der Rechner "Error" an. + * + * - Abschließend wird die Anzeige auf 11 Zeichen begrenzt, damit sie auf den Bildschirm passt. + */ public void pressEqualsKey() { - var result = switch(latestOperation) { + // Führt die gespeicherte Rechenoperation aus + 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(); }; - 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); + + // Wenn Ergebnis unendlich oder keine Zahl ist, Fehler anzeigen + if (Double.isInfinite(result) || Double.isNaN(result)) { + screen = "Error"; + return; // Methode beenden, damit nichts weiter ausgeführt wird + } + + // Ergebnis in normale Textform umwandeln (ohne Exponentialschreibweise) + screen = java.math.BigDecimal.valueOf(result) + .stripTrailingZeros() // entfernt überflüssige Nullen am Ende + .toPlainString(); // zeigt die Zahl normal an, z. B. "152399025" statt "1.52399025E8" + + // Wenn Ergebnis "-0" ist (kann bei negativen Zahlen entstehen), in "0" umwandeln + if (screen.equals("-0")) screen = "0"; + + // Anzeige auf maximal 11 Zeichen begrenzen (wie beim echten Taschenrechner) + if (screen.length() > 11) screen = screen.substring(0, 11); } } From 46f1aa835dcdc36d0969d60363420ee38693fdaa Mon Sep 17 00:00:00 2001 From: Jannick Date: Tue, 21 Oct 2025 13:48:10 +0200 Subject: [PATCH 5/5] teilaufgabe 3 zweiter bug fix --- .../java/htw/berlin/prog2/ha1/Calculator.java | 54 +++++++++++++++---- 1 file changed, 43 insertions(+), 11 deletions(-) diff --git a/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/src/main/java/htw/berlin/prog2/ha1/Calculator.java index ae0e4de..d7350b5 100644 --- a/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -59,7 +59,17 @@ public void pressClearKey() { * 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 */ + /** + * Setzt die binäre Operation (+, -, x, /) und speichert den aktuell sichtbaren Wert. + * Neu: akzeptiert auch "*" oder "×" als Alias für "x". + */ public void pressBinaryOperationKey(String operation) { + // --- NEU: Aliase auf "x" mappen, damit Multiplikation sicher erkannt wird --- + if ("*".equals(operation) || "×".equals(operation) || "X".equals(operation)) { + operation = "x"; + } + // --------------------------------------------------------------------------- + latestValue = Double.parseDouble(screen); latestOperation = operation; } @@ -137,9 +147,27 @@ public void pressNegativeKey() { * * - Abschließend wird die Anzeige auf 11 Zeichen begrenzt, damit sie auf den Bildschirm passt. */ + /** + * Führt die zuletzt gesetzte Operation mit dem aktuellen Bildschirmwert aus. + * Neu: + * - Division durch 0/NaN -> "Error" + * - Ergebnis auf 1 Nachkommastelle runden (HALF_UP), z. B. -4.6 + * - Ausgabe ohne Exponentialschreibweise (toPlainString) + * - "-0" wird zu "0" + * - Länge auf 11 Zeichen begrenzt (Displaylimit) + */ public void pressEqualsKey() { - // Führt die gespeicherte Rechenoperation aus - var result = switch (latestOperation) { + // Wenn noch keine Operation gesetzt ist: nichts tun (verhindert Exception) + if (latestOperation == null || latestOperation.isEmpty()) return; + + // Division durch 0 früh abfangen + if (latestOperation.equals("/") && Double.parseDouble(screen) == 0.0) { + screen = "Error"; + return; + } + + // Rechnen + double result = switch (latestOperation) { case "+" -> latestValue + Double.parseDouble(screen); case "-" -> latestValue - Double.parseDouble(screen); case "x" -> latestValue * Double.parseDouble(screen); @@ -147,21 +175,25 @@ public void pressEqualsKey() { default -> throw new IllegalArgumentException(); }; - // Wenn Ergebnis unendlich oder keine Zahl ist, Fehler anzeigen - if (Double.isInfinite(result) || Double.isNaN(result)) { + // Fehlerfälle (z. B. 0/0) -> "Error" + if (Double.isNaN(result) || Double.isInfinite(result)) { screen = "Error"; - return; // Methode beenden, damit nichts weiter ausgeführt wird + return; } - // Ergebnis in normale Textform umwandeln (ohne Exponentialschreibweise) - screen = java.math.BigDecimal.valueOf(result) - .stripTrailingZeros() // entfernt überflüssige Nullen am Ende - .toPlainString(); // zeigt die Zahl normal an, z. B. "152399025" statt "1.52399025E8" + // NEU: auf 1 Nachkommastelle runden (kaufmännisch) + java.math.BigDecimal rounded = java.math.BigDecimal + .valueOf(result) + .setScale(1, java.math.RoundingMode.HALF_UP); + + // Lesbar ohne Exponentialschreibweise ausgeben + screen = rounded.stripTrailingZeros().toPlainString(); - // Wenn Ergebnis "-0" ist (kann bei negativen Zahlen entstehen), in "0" umwandeln + // "-0" vermeiden if (screen.equals("-0")) screen = "0"; - // Anzeige auf maximal 11 Zeichen begrenzen (wie beim echten Taschenrechner) + // Display-Limit einhalten if (screen.length() > 11) screen = screen.substring(0, 11); } + }