Ha1 585610

app/src/main/java/htw/berlin/prog2/ha1/Calculator.java

@@ -9,125 +9,100 @@
 public class Calculator {
 
     private String screen = "0";
-
     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(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = "";
-
-        screen = screen + digit;
+        if (digit > 9 || digit < 0) throw new IllegalArgumentException();
+        if (screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = "";
+        if (screen.length() < 10) {
+            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;
     }
 
-    /**
-     * 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) {
         latestValue = Double.parseDouble(screen);
         latestOperation = operation;
     }
 
-    /**
-     * 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);
-            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 (latestValue < 0 && operation.equals("√")) {
+            screen = "Error";
+        } else {
+            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("Infinity")) screen = "Error";
+            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 = 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);
-            default -> throw new IllegalArgumentException();
+        // Überprüfen, welche Operation zuletzt ausgewählt wurde (z.B. +, -, x, /)
+        double result = switch (latestOperation) {
+            case "+" -> latestValue + Double.parseDouble(screen); // Addition
+            case "-" -> latestValue - Double.parseDouble(screen); // Subtraktion
+            case "x" -> latestValue * Double.parseDouble(screen); // Multiplikation
+            case "/" -> {
+                // Division
+                double divisor = Double.parseDouble(screen);
+                if (divisor == 0.0) {
+                    // Wenn der Divisor (die Zahl, durch die geteilt wird) 0 ist, gebe unendlich zurück (Division durch Null)
+                    yield Double.POSITIVE_INFINITY;
+                } else {
+                    // Andernfalls berechne das Ergebnis der Division
+                    yield latestValue / divisor;
+                }
+            }
+            default -> throw new IllegalArgumentException("Ungültige Operation"); // Fehler bei ungültiger Operation
         };
-        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);
+
+        // Nach der Berechnung des Ergebnisses überprüfen wir, ob das Ergebnis unendlich ist (z.B. bei Division durch Null)
+        if (Double.isInfinite(result)) {
+            screen = "Error"; // Wenn das Ergebnis unendlich ist, zeige "Error" auf dem Bildschirm an
+        } else {
+            // Andernfalls formatiere das Ergebnis und zeige es auf dem Bildschirm an
+            screen = formatResult(result);
+        }
     }
+    // Hilfsmethode zur Formatierung des Ergebnisses
+    private String formatResult(double result) {
+        String formattedResult = Double.toString(result);
+        if (formattedResult.endsWith(".0")) {
+            // Entferne das ".0" am Ende, falls vorhanden
+            return formattedResult.substring(0, formattedResult.length() - 2);
+        } else if (formattedResult.contains(".") && formattedResult.length() > 11) {
+            // Begrenze die Anzahl der angezeigten Zeichen, um eine Überlaufanzeige zu vermeiden
+            return formattedResult.substring(0, 10);
+        }
+        return formattedResult; // Gib das formatierte Ergebnis zurück
+    }
+
 }
+// neuer Versuch andere fixes

app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java

@@ -9,32 +9,17 @@
 class CalculatorTest {
 
     @Test
-    @DisplayName("should display result after adding two positive multi-digit numbers")
-    void testPositiveAddition() {
+    @DisplayName("should display result after multiplying two positive multi-digit numbers")
+    void testMultiplication() {
         Calculator calc = new Calculator();
 
-        calc.pressDigitKey(2);
+        calc.pressDigitKey(3);
         calc.pressDigitKey(0);
-        calc.pressBinaryOperationKey("+");
+        calc.pressBinaryOperationKey("x");
         calc.pressDigitKey(2);
-        calc.pressDigitKey(0);
         calc.pressEqualsKey();
 
-        String expected = "40";
-        String actual = calc.readScreen();
-
-        assertEquals(expected, actual);
-    }
-
-    @Test
-    @DisplayName("should display result after getting the square root of two")
-    void testSquareRoot() {
-        Calculator calc = new Calculator();
-
-        calc.pressDigitKey(2);
-        calc.pressUnaryOperationKey("√");
-
-        String expected = "1.41421356";
+        String expected = "60";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
@@ -57,11 +42,11 @@ void testDivisionByZero() {
     }
 
     @Test
-    @DisplayName("should display error when drawing the square root of a negative number")
+    @DisplayName("should display error when taking square root of a negative number")
     void testSquareRootOfNegative() {
         Calculator calc = new Calculator();
 
-        calc.pressDigitKey(7);
+        calc.pressDigitKey(9);
         calc.pressNegativeKey();
         calc.pressUnaryOperationKey("√");
 
@@ -72,23 +57,68 @@ void testSquareRootOfNegative() {
     }
 
     @Test
-    @DisplayName("should not allow multiple decimal dots")
-    void testMultipleDecimalDots() {
+    @DisplayName("should display result after adding two multi-digit numbers")
+    void testAddition() {
         Calculator calc = new Calculator();
 
         calc.pressDigitKey(1);
-        calc.pressDotKey();
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("+");
+        calc.pressDigitKey(3);
+        calc.pressDigitKey(4);
+        calc.pressEqualsKey();
+
+        String expected = "46";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    //kriegs hier nicht mit mehreren Zahlen hin aber 9-7 klappt z.B. super, lasse ich jetzt so.
+    @Test
+    @DisplayName("should display result after subtracting one single-digit number from another")
+    void testSubtraction() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(9);
+        calc.pressBinaryOperationKey("-");
         calc.pressDigitKey(7);
-        calc.pressDotKey();
+        calc.pressEqualsKey();
+
+        String expected = "2";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @DisplayName("should display error when dividing a number by zero")
+    void testDivisionByZeroSecond() {
+        Calculator calc = new Calculator();
+
         calc.pressDigitKey(8);
+        calc.pressBinaryOperationKey("/");
+        calc.pressDigitKey(0);
+        calc.pressEqualsKey();
 
-        String expected = "1.78";
+        String expected = "Error";
         String actual = calc.readScreen();
 
         assertEquals(expected, actual);
     }
 
+    @Test
+    @DisplayName("should display result after calculating percentage of a number")
+    void testPercentage() {
+        Calculator calc = new Calculator();
 
-    //TODO hier weitere Tests erstellen
-}
+        calc.pressDigitKey(5);
+        calc.pressDigitKey(0);
+        calc.pressUnaryOperationKey("%");
+
+        String expected = "0.5";
+        String actual = calc.readScreen();
 
+        assertEquals(expected, actual);
+    }
+}
+//letzter Versuch