HA1 Tobias Laag

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

@@ -1,48 +1,51 @@
 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.
+ * Eine Klasse, die das Verhalten eines Online-Taschenrechners imitiert,
+ * der 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
+ * diverse Bugs oder unvollständige Funktionen.
  */
 public class Calculator {
 
     private String screen = "0";
-
     private double latestValue;
-
     private String latestOperation = "";
 
     /**
-     * @return den aktuellen Bildschirminhalt als String
+     * Gibt den aktuellen Bildschirminhalt als String zurück.
+     *
+     * @return Der aktuelle Bildschirminhalt.
      */
     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
+     * 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 dazu, dass die gerade gedrückte Ziffer
+     * auf dem Bildschirm angezeigt oder rechts an die zuvor gedrückte Ziffer
+     * angehängt wird.
+     *
+     * @param digit Die Ziffer, deren Taste gedrückt wurde.
+     * @throws IllegalArgumentException Wenn die Ziffer nicht zwischen 0 und 9 liegt.
      */
     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") || latestValue == Double.parseDouble(screen)) screen = "";
 
         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.
+     * Einmaliges Drücken löscht die zuvor eingegebenen Ziffern auf dem Bildschirm,
+     * sodass "0" angezeigt wird, ohne zuvor zwischengespeicherte Werte zu löschen.
+     * Bei erneutem Drücken werden auch zwischengespeicherte Werte sowie der aktuelle
+     * Operationsmodus zurückgesetzt, sodass der Rechner wieder im Ursprungszustand ist.
      */
     public void pressClearKey() {
         screen = "0";
@@ -51,83 +54,118 @@ public void pressClearKey() {
     }
 
     /**
-     * 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
+     * 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 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.
      */
-    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
+     * 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.
+     * @throws IllegalArgumentException Wenn die Operation nicht bekannt ist.
      */
     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);
 
+        switch (operation) {
+            case "√":
+                screen = Double.toString(Math.sqrt(latestValue));
+                break;
+            case "%":
+                screen = Double.toString(latestValue / 100);
+                break;
+            case "1/x":
+                // Überprüfen, ob der Wert 0 ist
+                if (latestValue == 0) {
+                    screen = "Error"; // Setze den Bildschirm auf "Error"
+                    return; // Beende die Ausführung der Methode
+                }
+                screen = Double.toString(1 / latestValue); // 1/x Berechnung
+                break;
+            default:
+                throw new IllegalArgumentException();
+        }
+        screen = Double.toString(latestValue);
+        // Fehlerbehandlung für NaN
+        if (screen.equals("NaN")) screen = "Error";
+        // Begrenze die Anzahl der Stellen nach dem Komma
+        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.
+     * 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 zweiten 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.
+     * Zeigt der Bildschirm einen positiven Wert an, so wird ein "-" links
+     * angehängt, der Bildschirm aktualisiert und der 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.
+     * 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);
             case "/" -> latestValue / Double.parseDouble(screen);
             default -> throw new IllegalArgumentException();
         };
-        screen = Double.toString(result);
+
+        if (result == 0) {
+            screen = "0";
+        } else {
+            screen = Double.toString(result);
+        }
+
+
+        // Überprüfen, ob das Ergebnis "Infinity" ist
         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);
     }
 }
+
+

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

@@ -90,5 +90,54 @@ void testMultipleDecimalDots() {
 
 
     //TODO hier weitere Tests erstellen
+
+    @Test
+    @DisplayName("should display result after subtracting two positive numbers")
+    void testPositiveSubtraction() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(5);
+        calc.pressDigitKey(0);
+        calc.pressBinaryOperationKey("-");
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(0);
+        calc.pressEqualsKey();
+
+        String expected = "30";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @DisplayName("should display zero when multiplying any number by zero")
+    void testMultiplicationByZero() {
+        Calculator calc = new Calculator(); // Neue Instanz für diesen Test
+
+        calc.pressDigitKey(5); // Any number
+        calc.pressBinaryOperationKey("*"); // Multiplication operation
+        calc.pressDigitKey(0); // Multiply by zero
+        calc.pressEqualsKey(); // Press equals key
+
+        String expected = "0"; // Expecting "0" as string
+        String actual = calc.readScreen(); // Get the result as string
+
+        assertEquals(expected, actual); // Compare expected with actual
+    }
+
+    @Test
+    @DisplayName("should display error when inverting zero")
+    void testInverseOfZero() {
+        Calculator calc = new Calculator(); // Neue Instanz für diesen Test
+
+        calc.pressDigitKey(0); // Zifferntaste 0 drücken
+        calc.pressUnaryOperationKey("1/x"); // Inversions-Taste drücken
+
+        String expected = "Error"; // Erwartung: "Error" als String
+        String actual = calc.readScreen(); // Ergebnis als String abrufen
+
+        assertEquals(expected, actual); // Erwartetes mit aktuellem Ergebnis vergleichen
+    }
+
 }