From 6a16f76a55759b6fcc92aceb9c720d6a671b3412 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Sun, 27 Oct 2024 22:29:57 +0200 Subject: [PATCH 1/7] =?UTF-8?q?positiver=20gr=C3=BCner=20Test?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 21 +++++++++++++++++++ 1 file changed, 21 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..11975d5 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,26 @@ void testMultipleDecimalDots() { //TODO hier weitere Tests erstellen + + @Test + @DisplayName("should display result after subtracting two negative multi-digit numbers") + void testNegativeSubstraction() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(3); + calc.pressNegativeKey(); + calc.pressBinaryOperationKey("-"); + calc.pressDigitKey(8); + calc.pressNegativeKey(); + calc.pressEqualsKey(); + + String expected = "5"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + + + + } } From 8ea0db32c0d72c10b13e4426619e5819761743b7 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Mon, 28 Oct 2024 21:12:28 +0200 Subject: [PATCH 2/7] =?UTF-8?q?noch=20mehr=20gr=C3=BCne=20Tests?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/htw/berlin/prog2/ha1/Calculator.java | 10 +- .../htw/berlin/prog2/ha1/CalculatorTest.java | 117 +++++++++++++++++- 2 files changed, 121 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 84c04f2..aa067c1 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -23,7 +23,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 @@ -38,10 +38,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,7 +55,7 @@ public void pressClearKey() { * 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 + * Beim zweiten Drücken nach Eingabe einer weiteren Zahl wird direkt das 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 */ 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 11975d5..9cdf208 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -92,7 +92,7 @@ void testMultipleDecimalDots() { //TODO hier weitere Tests erstellen @Test - @DisplayName("should display result after subtracting two negative multi-digit numbers") + @DisplayName("should display result after subtracting two negative numbers") void testNegativeSubstraction() { Calculator calc = new Calculator(); @@ -107,9 +107,124 @@ void testNegativeSubstraction() { String actual = calc.readScreen(); assertEquals(expected, actual); + } + @Test + @DisplayName("should clear the previous number and display the new number") + void testClearKey() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(3); + calc.pressClearKey(); + calc.pressDigitKey(8); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(5); + calc.pressEqualsKey(); + calc.pressClearKey(); + calc.pressClearKey(); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + String expected = "2"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should display result after inverting a number") + void testInverseKey() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressUnaryOperationKey("1/x"); + + + String expected = "0.2"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should display result after adding two big numbers") + void testBigNumbers() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressDigitKey(9); + calc.pressEqualsKey(); + + String expected = "1999998"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should display error when dividing by zero after a prior operation") + void testDivisionByZeroAfterOperation() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(9); + calc.pressBinaryOperationKey("-"); + calc.pressDigitKey(4); + calc.pressEqualsKey(); // Ergebnis: 5 + + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(0); + calc.pressEqualsKey(); + + String expected = "Error"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + + @Test + @DisplayName("should repeat the last operation when equals is pressed multiple times") + void testRepeatedEquals() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(5); + calc.pressEqualsKey(); + + calc.pressEqualsKey(); + + String expected = "15"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } + @Test + @DisplayName("should display result after adding three numbers without pressing equals") + void testAddingThreeNumbers() { + Calculator calc = new Calculator(); + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(5); + String expected = "15"; + String actual = calc.readScreen(); + assertEquals(expected, actual); } + } From 62f081143d878dd13506c3c257c639325312158d Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Mon, 28 Oct 2024 22:31:14 +0200 Subject: [PATCH 3/7] Erster roter Test "testZeroDividedByZero". 0/0 soll "Error" ausgeben --- .../htw/berlin/prog2/ha1/CalculatorTest.java | 25 +++++++++---------- 1 file changed, 12 insertions(+), 13 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 9cdf208..1cb8144 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -209,22 +209,21 @@ void testRepeatedEquals() { assertEquals(expected, actual); } - @Test - @DisplayName("should display result after adding three numbers without pressing equals") - void testAddingThreeNumbers() { - Calculator calc = new Calculator(); - calc.pressDigitKey(5); - calc.pressBinaryOperationKey("+"); - calc.pressDigitKey(5); - calc.pressBinaryOperationKey("+"); - calc.pressDigitKey(5); + @Test + @DisplayName("should display error when dividing zero by zero") + void testZeroDividedByZero() { + Calculator calc = new Calculator(); - String expected = "15"; - String actual = calc.readScreen(); + calc.pressDigitKey(0); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(0); + calc.pressEqualsKey(); - assertEquals(expected, actual); - } + String expected = "Error"; + String actual = calc.readScreen(); + assertEquals(expected, actual); +} } From 6823414f159e6bda446ccbe5620ff10bad136b83 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Mon, 28 Oct 2024 22:32:50 +0200 Subject: [PATCH 4/7] =?UTF-8?q?Fix=20f=C3=BCr=20den=20ersten=20roter=20Tes?= =?UTF-8?q?t=20"testZeroDividedByZero".?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/src/main/java/htw/berlin/prog2/ha1/Calculator.java | 1 + 1 file changed, 1 insertion(+) 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 aa067c1..52375f2 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -129,5 +129,6 @@ public void pressEqualsKey() { 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("NaN")) screen = "Error"; } } From 87d0401f036b5d48e2cd0827d2ae23189e9ba8d7 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Sun, 3 Nov 2024 03:05:17 +0100 Subject: [PATCH 5/7] =?UTF-8?q?Fix=20f=C3=BCr=20den=20zweiten=20Test.=20Ic?= =?UTF-8?q?h=20kann=20jetzt=20ununterbrochen=20z.B.=20addieren,=20ohne=20p?= =?UTF-8?q?ressEqualsKey.=20Z.B.=201+1+1+1+1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Da ich den Code schon geschrieben habe und viel getestet, commite ich nur ein mal. --- .../java/htw/berlin/prog2/ha1/Calculator.java | 91 +++++++++++++------ .../htw/berlin/prog2/ha1/CalculatorTest.java | 46 ++++++---- 2 files changed, 90 insertions(+), 47 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 52375f2..a3f4782 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -10,10 +10,13 @@ public class Calculator { private String screen = "0"; - private double latestValue; + private double latestValue = 0; private String latestOperation = ""; + //Hilft zu erkennen, ob der Bildschirminhalt neu ist oder nicht + private boolean isNewInput = true; + /** * @return den aktuellen Bildschirminhalt als String */ @@ -25,7 +28,8 @@ 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. * 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. + * oder rechts an die zuvor gedrückte Ziffer angehängt angezeigt wird. Wird die Taste nach einer Operation gedrückt, + * wird der Bildschirminhalt zurückgesetzt. * @param digit Die Ziffer, deren Taste gedrückt wurde */ public void pressDigitKey(int digit) { @@ -33,7 +37,13 @@ public void pressDigitKey(int digit) { if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; - screen = screen + digit; + //Wenn eine Operationstaste gedrückt wurde, wird der Bildschirminhalt zurückgesetzt + if (isNewInput) { + screen = ""; + isNewInput = false; + } + + screen += digit; } /** @@ -48,6 +58,7 @@ public void pressClearKey() { screen = "0"; latestOperation = ""; latestValue = 0.0; + isNewInput = true; } /** @@ -60,32 +71,40 @@ 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); + calculateIntermediateResult(); latestOperation = operation; + isNewInput = 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. + * der Bildschirminhalt mit dem Ergebnis aktualisiert. Falls hierbei eine Quadratwurzel aus einer + * negativen Zahl berechnet werden soll, wird "Error" angezeigt. * @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); + double currentValue = Double.parseDouble(screen); + double result; + + if (operation.equals("√") && currentValue < 0) { + screen = "Error"; + isNewInput = true; + return; + } + + result = switch (operation) { + case "√" -> Math.sqrt(currentValue); + case "%" -> currentValue / 100; + case "1/x" -> 1 / currentValue; 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); - + screen = formatResult(result); + isNewInput = true; } + /** * 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 @@ -94,7 +113,7 @@ 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 += "."; } /** @@ -118,17 +137,35 @@ public void pressNegativeKey() { * 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); - default -> throw new IllegalArgumentException(); + calculateIntermediateResult(); + latestOperation = ""; // Setzt Operation zurück + } + + /** + * Berechnet das Zwischenergebnis der aktuellen Operation und aktualisiert den Bildschirminhalt. + * Wird aufgerufen, wenn eine binäre Operationstaste gedrückt wird oder die "="-Taste. + * Bei Division durch Null wird "Error" angezeigt. + */ + private void calculateIntermediateResult() { + double currentValue = Double.parseDouble(screen); + + latestValue = switch (latestOperation) { + case "+" -> latestValue + currentValue; + case "-" -> latestValue - currentValue; + case "x" -> latestValue * currentValue; + // Division durch Null wird als Fehler behandelt + case "/" -> currentValue == 0 ? Double.POSITIVE_INFINITY : latestValue / currentValue; + default -> currentValue; }; - 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("NaN")) screen = "Error"; + + screen = formatResult(latestValue); + isNewInput = true; + } + + private String formatResult(double result) { + if (Double.isInfinite(result)) return "Error"; + String resultStr = Double.toString(result); + if (resultStr.endsWith(".0")) resultStr = resultStr.substring(0, resultStr.length() - 2); + return resultStr.length() > 11 ? resultStr.substring(0, 10) : resultStr; } } 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 1cb8144..4ccd451 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -180,7 +180,7 @@ void testDivisionByZeroAfterOperation() { calc.pressDigitKey(9); calc.pressBinaryOperationKey("-"); calc.pressDigitKey(4); - calc.pressEqualsKey(); // Ergebnis: 5 + calc.pressEqualsKey(); calc.pressBinaryOperationKey("/"); calc.pressDigitKey(0); @@ -192,38 +192,44 @@ void testDivisionByZeroAfterOperation() { assertEquals(expected, actual); } + @Test - @DisplayName("should repeat the last operation when equals is pressed multiple times") - void testRepeatedEquals() { + @DisplayName("should display error when dividing zero by zero") + void testZeroDividedByZero() { Calculator calc = new Calculator(); - calc.pressDigitKey(5); - calc.pressBinaryOperationKey("+"); - calc.pressDigitKey(5); - calc.pressEqualsKey(); - + calc.pressDigitKey(0); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(0); calc.pressEqualsKey(); - String expected = "15"; + String expected = "Error"; String actual = calc.readScreen(); assertEquals(expected, actual); } @Test - @DisplayName("should display error when dividing zero by zero") - void testZeroDividedByZero() { - Calculator calc = new Calculator(); + @DisplayName("should display result after multiple operations") + void testMultipleOperations() { + Calculator calc = new Calculator(); - calc.pressDigitKey(0); - calc.pressBinaryOperationKey("/"); - calc.pressDigitKey(0); - calc.pressEqualsKey(); + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(5); + calc.pressBinaryOperationKey("-"); + calc.pressDigitKey(3); + calc.pressBinaryOperationKey("x"); + calc.pressDigitKey(2); + calc.pressBinaryOperationKey("/"); + calc.pressDigitKey(2); + calc.pressEqualsKey(); - String expected = "Error"; - String actual = calc.readScreen(); + String expected = "7"; + String actual = calc.readScreen(); + + assertEquals(expected, actual); + } - assertEquals(expected, actual); -} } From 96c40c5bfd3ba5bfc6b35c505cb3bfa4accc5969 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Sun, 3 Nov 2024 13:14:32 +0100 Subject: [PATCH 6/7] javadoc --- app/src/main/java/htw/berlin/prog2/ha1/Calculator.java | 7 +++++++ 1 file changed, 7 insertions(+) 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 a3f4782..fd00239 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -145,6 +145,7 @@ public void pressEqualsKey() { * Berechnet das Zwischenergebnis der aktuellen Operation und aktualisiert den Bildschirminhalt. * Wird aufgerufen, wenn eine binäre Operationstaste gedrückt wird oder die "="-Taste. * Bei Division durch Null wird "Error" angezeigt. + * */ private void calculateIntermediateResult() { double currentValue = Double.parseDouble(screen); @@ -162,6 +163,12 @@ private void calculateIntermediateResult() { isNewInput = true; } + /** + * Formatiert das Ergebnis als String, sodass es auf dem Bildschirm angezeigt werden kann. + * Entfernt ".0" am Ende von ganzen Zahlen. + * @param result das Ergebnis als double + * @return + */ private String formatResult(double result) { if (Double.isInfinite(result)) return "Error"; String resultStr = Double.toString(result); From 7990b5274163506096e81facf35794162eebafc5 Mon Sep 17 00:00:00 2001 From: Vladimir Pruzhanskyi Date: Sun, 3 Nov 2024 13:19:00 +0100 Subject: [PATCH 7/7] javadoc --- app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java | 3 ++- 1 file changed, 2 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 4ccd451..7567774 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -192,7 +192,7 @@ void testDivisionByZeroAfterOperation() { assertEquals(expected, actual); } - + //Gab "NaN" statt "Error" aus @Test @DisplayName("should display error when dividing zero by zero") void testZeroDividedByZero() { @@ -209,6 +209,7 @@ void testZeroDividedByZero() { assertEquals(expected, actual); } + //multple operations was not possible @Test @DisplayName("should display result after multiple operations") void testMultipleOperations() {