HA1

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

@@ -7,20 +7,22 @@
  * 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 int count = 0;
+
+    private boolean isNegative = 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.
@@ -29,10 +31,14 @@ public String readScreen() {
      * @param digit Die Ziffer, deren Taste gedrückt wurde
      */
     public void pressDigitKey(int digit) {
+        count = count + 1;
+
         if(digit > 9 || digit < 0) throw new IllegalArgumentException();
 
         if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = "";
 
+        if(isNegative) screen = "-";
+
         screen = screen + digit;
     }
 
@@ -45,11 +51,11 @@ public void pressDigitKey(int digit) {
      * im Ursprungszustand ist.
      */
     public void pressClearKey() {
+        count = 0;
         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.
@@ -63,7 +69,6 @@ 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.
@@ -83,9 +88,7 @@ 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
@@ -96,7 +99,6 @@ public void pressUnaryOperationKey(String operation) {
     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
@@ -105,6 +107,9 @@ public void pressDotKey() {
      * entfernt und der Inhalt fortan als positiv interpretiert.
      */
     public void pressNegativeKey() {
+        count = count + 1;
+
+        if(count == 1)isNegative = true;
         screen = screen.startsWith("-") ? screen.substring(1) : "-" + screen;
     }
 
@@ -116,18 +121,30 @@ public void pressNegativeKey() {
      * 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.
+     *   * Der letzte Operand (`lastOperand`) wird gespeichert, sobald "=" zum ersten Mal nach
+     *      * einer Operation gedrückt wird. Dieser Operand wird bei weiterer Addition-Berechnung verwendet.
+     *      * `latestValue` speichert das letzte Berechnungsergebnis, damit die Wiederholung der
+     *      * letzten Operation mit dem `lastOperand` möglich ist.
      */
+    private Double lastOperand = null;
     public void pressEqualsKey() {
-        var result = switch(latestOperation) {
-            case "+" -> latestValue + Double.parseDouble(screen);
+        double currentScreenValue = Double.parseDouble(screen);
+        if (latestOperation.isEmpty()) return;
+        if (lastOperand == null) {
+            lastOperand = currentScreenValue;
+        }
+
+        double result = switch(latestOperation) {
+            case "+" -> latestValue + lastOperand;
             case "-" -> latestValue - Double.parseDouble(screen);
             case "x" -> latestValue * Double.parseDouble(screen);
             case "/" -> latestValue / Double.parseDouble(screen);
             default -> throw new IllegalArgumentException();
         };
         screen = Double.toString(result);
+        latestValue = 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);
     }
-}
+}

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

@@ -90,5 +90,61 @@ void testMultipleDecimalDots() {
 
 
     //TODO hier weitere Tests erstellen
+    //Gibt das Ergebnis einer Subrtraktion zweier negativer Nummern aus
+    @Test
+    @DisplayName("should display result after substracting two negative numbers")
+    void testNegativeSubstracting() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(5);
+        calc.pressNegativeKey();
+        calc.pressBinaryOperationKey("-");
+        calc.pressDigitKey(6);
+        calc.pressNegativeKey();
+        calc.pressEqualsKey();
+
+        String expected = "1";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    @Test
+    @DisplayName("should display a negative number")
+    void testNegativeDigit() {
+        Calculator calc = new Calculator();
+
+        calc.pressNegativeKey();
+        calc.pressDigitKey(5);
+
+        String expected = "-5";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    //finish
+    @Test
+    @DisplayName("should display result after adding two positive multi-digit numbers and pressing equal sign again")
+    void testMultiplePositiveAddition() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("+");
+        calc.pressDigitKey(3);
+        calc.pressEqualsKey();
+
+        String expected1 = "5";
+        String actual1 = calc.readScreen();
+
+        assertEquals(expected1, actual1);
+
+        calc.pressEqualsKey();
+
+        String expected2 = "8";
+        String actual2 = calc.readScreen();
+
+        assertEquals(expected2, actual2);
+    }
+
+
 }