Kaan ha1

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

@@ -26,16 +26,22 @@ public String readScreen() {
      * 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.
+     * Es wird ein Fehler angezeigt, wenn mehr als 10 Ziffern eingegeben werden.
      * @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 = "";
+        // Überprüfung auf maximale Länge von 10 Ziffern.
+        if (screen.length() >= 10) return; // Ignoriert weitere Zifferneingaben, wenn die maximale Länge erreicht ist
+
+        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
@@ -69,21 +75,24 @@ public void pressBinaryOperationKey(String operation)  {
      * 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.
+     * Wenn der aktuelle Wert 0 ist und die Inversionsoperation gedrückt wird, 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);
+            case "√" -> Math.sqrt(latestValue);
+            case "%" -> latestValue / 100;
+            case "1/x" -> {
+                if (latestValue == 0) yield Double.NaN; // Fehler, wenn 1/0
+                yield 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.equals("Infinity")) screen = "Error";
+        if (screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10);
     }
 
     /**
@@ -118,6 +127,7 @@ 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);

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

@@ -87,8 +87,53 @@ void testMultipleDecimalDots() {
 
         assertEquals(expected, actual);
     }
+    @Test
+    @DisplayName("should toggle negative sign correctly")
+    void testToggleNegativeSign() {
+        Calculator calc = new Calculator();
+        calc.pressDigitKey(5);
+        calc.pressNegativeKey();
+        calc.pressNegativeKey();
+        String expected = "5";
+        String actual = calc.readScreen();
+        assertEquals(expected, actual);
+    }
+
+
+    @Test
+    @DisplayName("should display error when performing unary operation with invalid input")
+    void testInvalidUnaryOperationInput() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(0); // 0 für 1/x
+        calc.pressUnaryOperationKey("1/x");
+
+        String expected = "Error"; // Erwartetes Verhalten: 1/0 führt zu einem Fehler
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
+
+
+
+    @Test
+    @DisplayName("should not accept more than 10 digits")
+    void testTooManyDigits() {
+        Calculator calc = new Calculator();
+
+        // Eingabe von 11 Ziffern, was über die 10-stellige Grenze hinausgeht
+        for (int i = 0; i < 11; i++) {
+            calc.pressDigitKey(1);
+        }
+
+        String expected = "1111111111"; // Der Bildschirm sollte nur die ersten 10 Ziffern anzeigen
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
 
 
-    //TODO hier weitere Tests erstellen
+ //TODO hier weitere Tests erstellen
 }