From 392387861c9dee0b8932184512198f47421551a3 Mon Sep 17 00:00:00 2001 From: KaramAlBatta Date: Wed, 16 Apr 2025 13:21:31 +0200 Subject: [PATCH 1/3] =?UTF-8?q?1=20Gr=C3=BCner=20Test,=20Zwei=20Rote=20Tes?= =?UTF-8?q?ts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 51 ++++++++++++++++++- 1 file changed, 50 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 ddff0daf..af8b5dc2 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,54 @@ void testMultipleDecimalDots() { //TODO hier weitere Tests erstellen -} + @Test + @DisplayName("should calculate percentage of a number correctly") + void testPercentageCalculation() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressDigitKey(0); + calc.pressUnaryOperationKey("%"); + + String expected = "0.5"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + @Test + @DisplayName("should clear the calculator display and reset state") + void testClearKey() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(3); + calc.pressClearKey(); + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String expected = "7"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should handle binary operations correctly") + void testBinaryOperations() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(4); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(2); + calc.pressBinaryOperationKey("x"); + calc.pressDigitKey(3); + calc.pressEqualsKey(); + + String expected = "10"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } +} \ No newline at end of file From dace084caa015bc32b97389fc1a716b2f3049aa5 Mon Sep 17 00:00:00 2001 From: KaramAlBatta Date: Sun, 20 Apr 2025 20:20:40 +0200 Subject: [PATCH 2/3] =?UTF-8?q?1=20Gr=C3=BCner=20Test,=20Zwei=20Rote=20Tes?= =?UTF-8?q?ts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/htw/berlin/prog2/ha1/Calculator.java | 2 +- .../htw/berlin/prog2/ha1/CalculatorTest.java | 66 +++++++------------ 2 files changed, 25 insertions(+), 43 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..a68ecbec 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -130,4 +130,4 @@ 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); } -} +} \ 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 af8b5dc2..8911d3fb 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -70,74 +70,56 @@ void testSquareRootOfNegative() { assertEquals(expected, actual); } - @Test - @DisplayName("should not allow multiple decimal dots") - void testMultipleDecimalDots() { + @DisplayName("should start new operation after percentage") + void testAfterPercentage() { Calculator calc = new Calculator(); calc.pressDigitKey(1); - calc.pressDotKey(); - calc.pressDigitKey(7); - calc.pressDotKey(); - calc.pressDigitKey(8); - - String expected = "1.78"; - String actual = calc.readScreen(); - - assertEquals(expected, actual); - } - - - //TODO hier weitere Tests erstellen - - @Test - @DisplayName("should calculate percentage of a number correctly") - void testPercentageCalculation() { - Calculator calc = new Calculator(); - - calc.pressDigitKey(5); calc.pressDigitKey(0); - calc.pressUnaryOperationKey("%"); - - String expected = "0.5"; - String actual = calc.readScreen(); + calc.pressDigitKey(0); + calc.pressUnaryOperationKey("%"); // 100% = 1.0 + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(3); + calc.pressEqualsKey(); - assertEquals(expected, actual); + String expected = "8"; // 5 + 3 = 8 + assertEquals(expected, calc.readScreen()); } @Test - @DisplayName("should clear the calculator display and reset state") - void testClearKey() { + @DisplayName("should start new operation after percentage") + void testAfterPercentageFixed() { Calculator calc = new Calculator(); + calc.pressDigitKey(1); + calc.pressDigitKey(0); + calc.pressDigitKey(0); + calc.pressUnaryOperationKey("%"); // 100% = 1.0 + calc.pressClearKey(); calc.pressDigitKey(5); calc.pressBinaryOperationKey("+"); calc.pressDigitKey(3); - calc.pressClearKey(); - calc.pressDigitKey(2); calc.pressEqualsKey(); - String expected = "7"; - String actual = calc.readScreen(); - - assertEquals(expected, actual); + assertEquals("8", calc.readScreen()); } - @Test @DisplayName("should handle binary operations correctly") - void testBinaryOperations() { + void testBinaryOperations1() { Calculator calc = new Calculator(); - calc.pressDigitKey(4); - calc.pressBinaryOperationKey("+"); calc.pressDigitKey(2); calc.pressBinaryOperationKey("x"); calc.pressDigitKey(3); - calc.pressEqualsKey(); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(4); + calc.pressEqualsKey(); // 2 × 3 + 4 = 10 String expected = "10"; String actual = calc.readScreen(); assertEquals(expected, actual); } -} \ No newline at end of file +} + From 28ddce48aeebca6f0b741406a8911b39fa5462a7 Mon Sep 17 00:00:00 2001 From: KaramAlBatta Date: Sun, 20 Apr 2025 20:23:28 +0200 Subject: [PATCH 3/3] =?UTF-8?q?Bugfix=20f=C3=BCr=20den=20letzten=20Test?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/htw/berlin/prog2/ha1/Calculator.java | 93 +++++-------------- 1 file changed, 21 insertions(+), 72 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 a68ecbec..cdad4102 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -1,76 +1,43 @@ 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; - private String latestOperation = ""; + private boolean newInputExpected = false; - /** - * @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(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; + if(screen.equals("0") || latestValue == Double.parseDouble(screen) || newInputExpected) { + screen = ""; + newInputExpected = false; + } screen = 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() { screen = "0"; latestOperation = ""; latestValue = 0.0; + newInputExpected = false; } - /** - * 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) { + public void pressBinaryOperationKey(String operation) { + if (!latestOperation.isEmpty()) { + pressEqualsKey(); + } latestValue = Double.parseDouble(screen); latestOperation = operation; + newInputExpected = true; } - /** - * 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; @@ -83,51 +50,33 @@ public void pressUnaryOperationKey(String operation) { screen = Double.toString(result); 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 + "."; } - /** - * 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() { + if (latestOperation.isEmpty()) return; + + double currentValue = Double.parseDouble(screen); 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); + case "+" -> latestValue + currentValue; + case "-" -> latestValue - currentValue; + case "x" -> latestValue * currentValue; + case "/" -> latestValue / currentValue; 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); + + latestValue = result; + newInputExpected = true; } } \ No newline at end of file