From 3dcafcb36a1a6d8fb0254e27a84510da2a6c1efd Mon Sep 17 00:00:00 2001 From: Murad Miller Date: Sun, 3 Nov 2024 22:48:31 +0100 Subject: [PATCH 1/3] =?UTF-8?q?Aufgabe=201:=20Neuer=20gr=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 ddff0da..fbd2463 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("sollte eine Zahl korrekt addieren, wenn die andere Zahl Null ist") + void testAdditionMitNull() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(8); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(0); + calc.pressEqualsKey(); + + String erwartet = "8"; + String aktuell = calc.readScreen(); + + assertEquals(erwartet, aktuell); + } } From 2a82e83c8265a390f5dcb1bef1d7d9a4be4ee468 Mon Sep 17 00:00:00 2001 From: Murad Miller Date: Sun, 3 Nov 2024 23:24:02 +0100 Subject: [PATCH 2/3] Aufgabe 2: Zwei neue rote Tests --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 45 ++++++++++++++++--- 1 file changed, 38 insertions(+), 7 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 fbd2463..637938b 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -91,19 +91,50 @@ void testMultipleDecimalDots() { //TODO hier weitere Tests erstellen @Test - @DisplayName("sollte eine Zahl korrekt addieren, wenn die andere Zahl Null ist") - void testAdditionMitNull() { + @DisplayName("should repeat last addition when equals is pressed consecutively") + void testRepeatedEqualsForAddition() { Calculator calc = new Calculator(); - calc.pressDigitKey(8); + calc.pressDigitKey(5); calc.pressBinaryOperationKey("+"); - calc.pressDigitKey(0); - calc.pressEqualsKey(); + calc.pressDigitKey(3); + calc.pressEqualsKey(); // ergibt 8 + calc.pressEqualsKey(); // sollte 8 + 3 wiederholen und 11 ergeben + calc.pressEqualsKey(); // sollte erneut 3 addieren und 14 ergeben + + String expected = "14"; // Erwartet: 5 + 3 + 3 + 3 = 14 + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + @Test + @DisplayName("sollte nur den aktuellen Eintrag löschen beim ersten Drücken der Clear-Taste") + void testClearKeySinglePress() { + Calculator calc = new Calculator(); + + // Eingabe einer Zahl und einer Operation + calc.pressDigitKey(9); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(1); + + // Erstes Drücken der Clear-Taste + calc.pressClearKey(); - String erwartet = "8"; + String erwartet = "0"; // Der Bildschirm sollte "0" anzeigen String aktuell = calc.readScreen(); assertEquals(erwartet, aktuell); + + // Überprüfen, ob der Operationsmodus und latestValue erhalten geblieben sind + // Zum Beispiel sollte das Hinzufügen fortgesetzt werden, wenn eine weitere Zahl eingegeben wird + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String erwartetNachAddition = "11"; // 9 + 2 = 11 + String aktuellNachAddition = calc.readScreen(); + + assertEquals(erwartetNachAddition, aktuellNachAddition); } -} + +} From 869c0beeb3a3c9f458ca435f131068d8e6064233 Mon Sep 17 00:00:00 2001 From: Murad Miller Date: Sun, 3 Nov 2024 23:55:00 +0100 Subject: [PATCH 3/3] Aufgabe 3: Zwei neue rote Tests die funktionieren --- .../java/htw/berlin/prog2/ha1/Calculator.java | 127 +++++------------- 1 file changed, 36 insertions(+), 91 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..0c70959 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -1,133 +1,78 @@ package htw.berlin.prog2.ha1; -/** - * Eine Klasse, die das Verhalten des Online Taschenrechners imitiert, welcher auf - * https://www.online-calculator.com/ aufgerufen werden kann (ohne die Memory-Funktionen) - * und dessen Bildschirm bis zu zehn Ziffern plus einem Dezimaltrennzeichen darstellen kann. - * Enthält mit Absicht noch diverse Bugs oder unvollständige Funktionen. - */ public class Calculator { private String screen = "0"; + private double latestValue; // Letzter Operandenwert + private String latestOperation = ""; // Letzte Operation - private double latestValue; - - private String latestOperation = ""; - - /** - * @return den aktuellen Bildschirminhalt als String - */ public String readScreen() { return screen; } - /** - * 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. - * 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 - */ public void pressDigitKey(int digit) { - if(digit > 9 || digit < 0) throw new IllegalArgumentException(); + if (digit > 9 || digit < 0) throw new IllegalArgumentException(); - if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; + if (screen.equals("0")) screen = ""; // Reset, wenn der aktuelle Bildschirm 0 ist - screen = screen + digit; + screen += 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. - * Wird daraufhin noch einmal die Taste gedrückt, dann werden auch zwischengespeicherte - * Werte sowie der aktuelle Operationsmodus zurückgesetzt, so dass der Rechner wieder - * im Ursprungszustand ist. - */ public void pressClearKey() { + // Nur den Bildschirm zurücksetzen, ohne die Operationen oder Werte zu reseten screen = "0"; - latestOperation = ""; - latestValue = 0.0; } - /** - * 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. - * 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 - */ - public void pressBinaryOperationKey(String operation) { - latestValue = Double.parseDouble(screen); + public void pressBinaryOperationKey(String operation) { + // Nur den Modus setzen, keine Berechnung durchführen + if (!screen.equals("0")) { + latestValue = Double.parseDouble(screen); // Speichern der letzten Zahl + } latestOperation = operation; + screen = "0"; // Bildschirm zurücksetzen für die nächste Eingabe } - /** - * Empfängt den Wert einer gedrückten unären Operationstaste, also eine der drei Operationen - * Quadratwurzel, Prozent, Inversion, welche nur einen Operanden benötigen. - * Beim Drücken der Taste wird direkt die Operation auf den aktuellen Zahlenwert angewendet und - * der Bildschirminhalt mit dem Ergebnis aktualisiert. - * @param operation "√" für Quadratwurzel, "%" für Prozent, "1/x" für Inversion - */ 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); + var result = switch (operation) { + case "√" -> Math.sqrt(latestValue); + case "%" -> latestValue / 100; + case "1/x" -> 1 / latestValue; 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); - + if (screen.equals("NaN")) screen = "Error"; + if (screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); } - /** - * Empfängt den Befehl der gedrückten Dezimaltrennzeichentaste, im Englischen üblicherweise "." - * Fügt beim ersten Mal Drücken dem aktuellen Bildschirminhalt das Trennzeichen auf der rechten - * 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. - */ public void pressDotKey() { - if(!screen.contains(".")) screen = screen + "."; + if (!screen.contains(".")) screen += "."; } - /** - * Empfängt den Befehl der gedrückten Vorzeichenumkehrstaste ("+/-"). - * Zeigt der Bildschirm einen positiven Wert an, so wird ein "-" links angehängt, der Bildschirm - * aktualisiert und die Inhalt fortan als negativ interpretiert. - * Zeigt der Bildschirm bereits einen negativen Wert mit führendem Minus an, dann wird dieses - * entfernt und der Inhalt fortan als positiv interpretiert. - */ public void pressNegativeKey() { screen = screen.startsWith("-") ? screen.substring(1) : "-" + screen; } - /** - * Empfängt den Befehl der gedrückten "="-Taste. - * Wurde zuvor keine Operationstaste gedrückt, passiert nichts. - * Wurde zuvor eine binäre Operationstaste gedrückt und zwei Operanden eingegeben, wird das - * Ergebnis der Operation angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt. - * Wird die Taste weitere Male gedrückt (ohne andere Tasten dazwischen), so wird die letzte - * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt - * und das Ergebnis direkt angezeigt. - */ 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); + // Wenn keine Operation gesetzt ist, nichts tun + if (latestOperation.isEmpty()) return; + + double currentValue = Double.parseDouble(screen); + var result = switch (latestOperation) { + case "+" -> latestValue + currentValue; + case "-" -> latestValue - currentValue; + case "x" -> latestValue * currentValue; + case "/" -> currentValue == 0 ? Double.NaN : latestValue / currentValue; // Division durch null behandeln default -> throw new IllegalArgumentException(); }; + + // Aktualisiere den Bildschirm mit dem Ergebnis 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 (screen.equals("Infinity") || screen.equals("NaN")) screen = "Error"; + if (screen.endsWith(".0")) screen = screen.substring(0, screen.length() - 2); + if (screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); + + // Speichere das Ergebnis als latestValue für die nächste Verwendung + latestValue = result; // Update latestValue für wiederholte Gleichheitsoperationen } }