From 415804dca6836531f816bd9f794a87d7721fb017 Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 15:54:37 +0100 Subject: [PATCH 1/6] =?UTF-8?q?Dieser=20Testfall=20zeigt,=20dass=20eine=20?= =?UTF-8?q?Multiplikation=20mit=20zwei=20Zahlen=20durchgef=C3=BChrt=20wurd?= =?UTF-8?q?e=20und=20das=20erwartete=20Ergebnis=20angezeigt=20wird.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 16 +++++++++++++++- 1 file changed, 15 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 ddff0da..97a95b7 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -87,8 +87,22 @@ void testMultipleDecimalDots() { assertEquals(expected, actual); } + @Test + @DisplayName("should display result after multiplying two positive numbers") + void testMultiplication() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("x"); + calc.pressDigitKey(8); + calc.pressEqualsKey(); + String expected = "40"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + + } - //TODO hier weitere Tests erstellen } From f236a42250f3a8614d2d192fa3e5fbdfa8904c01 Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 17:34:00 +0100 Subject: [PATCH 2/6] =?UTF-8?q?Dieser=20Testfall=20sollte=20zeigen,=20ob?= =?UTF-8?q?=20der=20Taschenrechner=20aufeinanderfolgende=20Subtraktionen?= =?UTF-8?q?=20korrekt=20berechnet=20und=20das=20erwartete=20Endergebnis=20?= =?UTF-8?q?anzeigt.=20In=20diesem=20Fall=20sollte=20der=20Rechner=20bei=20?= =?UTF-8?q?der=20Berechnung,=20das=20Ergebnis=204=20liefern.=20Der=20Test?= =?UTF-8?q?=20schl=C3=A4gt=20jedoch=20fehl,=20da=20der=20Rechner=20stattde?= =?UTF-8?q?ssen=20das=20Ergebnis=200=20zur=C3=BCckgibt,=20was=20darauf=20h?= =?UTF-8?q?indeutet,=20dass=20die=20Zwischenergebnisse=20nicht=20korrekt?= =?UTF-8?q?=20berechnet=20oder=20gespeichert=20werden.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 17 +++++++++++++++++ 1 file changed, 17 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 97a95b7..344a816 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -104,5 +104,22 @@ void testMultiplication() { } + @Test + @DisplayName("should handle consecutive subtractions correctly") + void testConsecutiveSubtraction() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(8); + calc.pressBinaryOperationKey("-"); + calc.pressDigitKey(2); + calc.pressBinaryOperationKey("-"); + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String expected = "4"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } } From 981e9b18fc514897acda690fdae47e322dda432c Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 18:06:30 +0100 Subject: [PATCH 3/6] Testfall 3 Teilaufgabe 2 --- .../java/htw/berlin/prog2/ha1/CalculatorTest.java | 14 ++++++++++++++ 1 file changed, 14 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 344a816..fd91fe2 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -121,5 +121,19 @@ void testConsecutiveSubtraction() { assertEquals(expected, actual); } + + @Test + @DisplayName("should handle decimal point at the start of input") + void testDecimalPoint() { + Calculator calc = new Calculator(); + + calc.pressDotKey(); + calc.pressDigitKey(2); + + String expected = "0.2"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } } From 28fdf35e3ad8653ab94f4d476061da09cff07b18 Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 18:07:24 +0100 Subject: [PATCH 4/6] Testfall 3 Teilaufgabe 2 --- 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 fd91fe2..e2cf4a4 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -134,6 +134,7 @@ void testDecimalPoint() { String actual = calc.readScreen(); assertEquals(expected, actual); + } } From be17ce84454592cc7886da1a1aa1cb49c00798b7 Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 19:32:40 +0100 Subject: [PATCH 5/6] Testfall 2 Teilaufgabe 3 --- .../java/htw/berlin/prog2/ha1/Calculator.java | 42 +++++++++++++++++-- 1 file changed, 39 insertions(+), 3 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 84c04f2..2d0c86f 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -50,6 +50,29 @@ public void pressClearKey() { latestValue = 0.0; } + /** + * Führt die angegebene Operation auf 2 Operanden aus und gibt das Ergebnis zurück. + * Falls eine Division durch 0 stattfindet, gibt die Methode "Double.POSITIVE_INFINITY" zurück, + * was im Anzeigebildschirm später als "Error" dargestellt wird. Dieser spezielle Wert signalisiert, + * dass das Ergebnis mathematisch unendlich ist und über die darstellbare Zahl hinausgeht. + * @param operation Die auszuführende Operation: "+" für Addition, "-" für Subtraktion, + * "x" für Multiplikation, "/" für Division. + * @param left der linke Operand + * @param right der rechte Operand + * @return Das Ergebnis der ausgeführten Operation als double. Gibt `Double.POSITIVE_INFINITY` zurück, + * falls eine Division durch Null auftritt, was später als "Error" auf dem Bildschirm angezeigt wird. + * @throws IllegalArgumentException falls eine unbekannte Operation übergeben wird. + */ + private double applyOperation(String operation, double left, double right) { + return switch (operation) { + case "+" -> left + right; + case "-" -> left - right; + case "x" -> left * right; + case "/" -> right == 0 ? Double.POSITIVE_INFINITY : left / right; + default -> throw new IllegalArgumentException("Unknown operation: " + operation); + }; + } + /** * 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. @@ -57,11 +80,22 @@ public void pressClearKey() { * 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. + * Die Methode wurde daraufhin erweitert, damit wir die Zwischenergebnisse sofort berechnet werden, wenn + * neue Operationen gedrückt werden. Dies stellt hierbei sicher, dass die aufeinanderfolgenden Operationen + * korrekt verarbeitet werden. * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division */ - public void pressBinaryOperationKey(String operation) { - latestValue = Double.parseDouble(screen); + public void pressBinaryOperationKey(String operation) { + double currentValue = Double.parseDouble(screen); + + if (!latestOperation.isEmpty()) { + currentValue = applyOperation(latestOperation, latestValue, currentValue); + screen = String.valueOf(currentValue); + } + + latestValue = currentValue; latestOperation = operation; + screen = "0"; } /** @@ -94,7 +128,8 @@ public void pressUnaryOperationKey(String operation) { * Beim zweimaligem Drücken, oder wenn bereits ein Trennzeichen angezeigt wird, passiert nichts. */ public void pressDotKey() { - if(!screen.contains(".")) screen = screen + "."; + if(!screen.contains(".")) + screen = screen + "."; } /** @@ -130,4 +165,5 @@ public void pressEqualsKey() { if(screen.endsWith(".0")) screen = screen.substring(0,screen.length()-2); if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); } + } From 2df5b03d7bfdbfda761e32d74ad36c89494f556e Mon Sep 17 00:00:00 2001 From: lebuile Date: Tue, 29 Oct 2024 19:58:18 +0100 Subject: [PATCH 6/6] Testfall 3 Teilaufgabe 3 --- .../java/htw/berlin/prog2/ha1/Calculator.java | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 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 2d0c86f..013a39a 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -24,16 +24,22 @@ 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. + * Wenn der Bildschirm "0" anzeigt und keine Dezimalstelle vorhanden ist, wird die führende Null + * entfernt, bevor die neue Ziffer angezeigt wird. Andersfalls wird die Ziffer rechts an die vorhandene + * Zahl angehängt. Das ermöglicht es, dass Ziffern an bestehenden Werten oder Dezimalzahlen angefügt + * werden, ohne dass führende Nullen verbleiben. * 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 + * @param digit Die Ziffer, deren Taste gedrückt wurde. + * @throws IllegalArgumentException wenn die Ziffer außerhalb des Bereiches 0-9 liegt. */ public void pressDigitKey(int digit) { if(digit > 9 || digit < 0) throw new IllegalArgumentException(); - if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; - - screen = screen + digit; + if(screen.equals("0") && !screen.contains(".")){ + screen = ""; + } + screen += digit; } /** @@ -126,10 +132,13 @@ public void pressUnaryOperationKey(String operation) { * Seite hinzu und aktualisiert den Bildschirm. Daraufhin eingegebene Zahlen werden rechts vom * Trennzeichen angegeben und daher als Dezimalziffern interpretiert. * Beim zweimaligem Drücken, oder wenn bereits ein Trennzeichen angezeigt wird, passiert nichts. + * Falls der Bildschirm nur "0" anzeigt oder leer ist, wird automatisch "0." hinzugefügt, um sicherzustellen, + * dass das Dezimalformat korrekt ist. Diese Änderung stellt sicher, dass die Dezimalzahlen wie angezeigt werden. */ public void pressDotKey() { - if(!screen.contains(".")) - screen = screen + "."; + if(!screen.contains(".")) { + screen = (screen.equals("0") || screen.isEmpty()) ? "0." : screen + "."; + } } /**