Skip to content

ha1 #142

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 3 commits into
base: main
Choose a base branch
from
Open

ha1 #142

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3923878
1 Grüner Test, Zwei Rote Tests
KaramAlBatta Apr 16, 2025
dace084
1 Grüner Test, Zwei Rote Tests
KaramAlBatta Apr 20, 2025
28ddce4
Bugfix für den letzten Test
KaramAlBatta Apr 20, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
95 changes: 22 additions & 73 deletions app/src/main/java/htw/berlin/prog2/ha1/Calculator.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,76 +1,43 @@
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.
*/
public class Calculator {

private String screen = "0";

private double latestValue;

private String latestOperation = "";
private boolean newInputExpected = 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.
* 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 = "";
if(screen.equals("0") || latestValue == Double.parseDouble(screen) || newInputExpected) {
screen = "";
newInputExpected = false;
}

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;
newInputExpected = false;
}

/**
* 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) {
if (!latestOperation.isEmpty()) {
pressEqualsKey();
}
latestValue = Double.parseDouble(screen);
latestOperation = operation;
newInputExpected = 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.
* @param operation "√" für Quadratwurzel, "%" für Prozent, "1/x" für Inversion
*/
public void pressUnaryOperationKey(String operation) {
latestValue = Double.parseDouble(screen);
latestOperation = operation;
Expand All @@ -83,51 +50,33 @@ 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
* 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 + ".";
}

/**
* 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() {
if (latestOperation.isEmpty()) return;

double currentValue = Double.parseDouble(screen);
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 + currentValue;
case "-" -> latestValue - currentValue;
case "x" -> latestValue * currentValue;
case "/" -> latestValue / currentValue;
default -> throw new IllegalArgumentException();
};
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);

latestValue = result;
newInputExpected = true;
}
}
}
51 changes: 41 additions & 10 deletions app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -70,25 +70,56 @@ void testSquareRootOfNegative() {

assertEquals(expected, actual);
}
@Test
@DisplayName("should start new operation after percentage")
void testAfterPercentage() {
Calculator calc = new Calculator();

calc.pressDigitKey(1);
calc.pressDigitKey(0);
calc.pressDigitKey(0);
calc.pressUnaryOperationKey("%"); // 100% = 1.0
calc.pressDigitKey(5);
calc.pressBinaryOperationKey("+");
calc.pressDigitKey(3);
calc.pressEqualsKey();

String expected = "8"; // 5 + 3 = 8
assertEquals(expected, calc.readScreen());
}
@Test
@DisplayName("should not allow multiple decimal dots")
void testMultipleDecimalDots() {
@DisplayName("should start new operation after percentage")
void testAfterPercentageFixed() {
Calculator calc = new Calculator();

calc.pressDigitKey(1);
calc.pressDotKey();
calc.pressDigitKey(7);
calc.pressDotKey();
calc.pressDigitKey(8);
calc.pressDigitKey(0);
calc.pressDigitKey(0);
calc.pressUnaryOperationKey("%"); // 100% = 1.0
calc.pressClearKey();
calc.pressDigitKey(5);
calc.pressBinaryOperationKey("+");
calc.pressDigitKey(3);
calc.pressEqualsKey();

assertEquals("8", calc.readScreen());
}
@Test
@DisplayName("should handle binary operations correctly")
void testBinaryOperations1() {
Calculator calc = new Calculator();

String expected = "1.78";
calc.pressDigitKey(2);
calc.pressBinaryOperationKey("x");
calc.pressDigitKey(3);
calc.pressBinaryOperationKey("+");
calc.pressDigitKey(4);
calc.pressEqualsKey(); // 2 × 3 + 4 = 10

String expected = "10";
String actual = calc.readScreen();

assertEquals(expected, actual);
}


//TODO hier weitere Tests erstellen
}

Loading