mirror of
https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git
synced 2024-11-25 19:49:44 +01:00
Merge branch 'main' into 'gui'
# Conflicts: # Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java # Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy # Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/Player.java
This commit is contained in:
Johannes Schmelz
commit
0c2b266f5e
@ -19,6 +19,7 @@ import com.jme3.input.controls.KeyTrigger;
|
|||||||
import com.jme3.input.controls.MouseButtonTrigger;
|
import com.jme3.input.controls.MouseButtonTrigger;
|
||||||
import com.jme3.system.AppSettings;
|
import com.jme3.system.AppSettings;
|
||||||
import com.simsilica.lemur.GuiGlobals;
|
import com.simsilica.lemur.GuiGlobals;
|
||||||
|
import com.simsilica.lemur.Label;
|
||||||
import com.simsilica.lemur.style.BaseStyles;
|
import com.simsilica.lemur.style.BaseStyles;
|
||||||
import pp.monopoly.game.client.MonopolyClient;
|
import pp.monopoly.game.client.MonopolyClient;
|
||||||
import pp.monopoly.client.gui.SettingsMenu;
|
import pp.monopoly.client.gui.SettingsMenu;
|
||||||
|
|||||||
@ -7,4 +7,9 @@ description = 'Monopoly common model'
|
|||||||
dependencies {
|
dependencies {
|
||||||
api project(":common")
|
api project(":common")
|
||||||
api libs.jme3.networking
|
api libs.jme3.networking
|
||||||
|
testImplementation libs.mockito.core
|
||||||
|
|
||||||
|
testImplementation project(":monopoly:client")
|
||||||
|
testImplementation project(":monopoly:model")
|
||||||
|
testImplementation project(":monopoly:server")
|
||||||
}
|
}
|
||||||
@ -1,3 +1,4 @@
|
|||||||
|
/*
|
||||||
package pp.monopoly;
|
package pp.monopoly;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
import static org.junit.Assert.assertNotNull;
|
import static org.junit.Assert.assertNotNull;
|
||||||
@ -383,3 +384,4 @@ public class Testhandbuch {
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
*/
|
||||||
@ -1,30 +1,106 @@
|
|||||||
package pp.monopoly.client;
|
package pp.monopoly.client;
|
||||||
|
|
||||||
import com.jme3.input.KeyInput;
|
|
||||||
import com.jme3.scene.Spatial;
|
import com.jme3.scene.Spatial;
|
||||||
import com.simsilica.lemur.Button;
|
import com.jme3.scene.Node;
|
||||||
import org.junit.Before;
|
import org.junit.Before;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
|
|
||||||
import static org.junit.Assert.assertNotNull;
|
import static org.junit.Assert.assertNotNull;
|
||||||
import static org.junit.Assert.assertNull;
|
import static org.mockito.Mockito.*;
|
||||||
|
|
||||||
public class ClientLogicTest {
|
public class ClientLogicTest {
|
||||||
|
|
||||||
private MonopolyApp app;
|
private MonopolyApp app;
|
||||||
|
private Node guiNodeMock;
|
||||||
|
|
||||||
@Before
|
@Before
|
||||||
public void setUp() {
|
public void setUp() {
|
||||||
app = new MonopolyApp();
|
// Erstelle eine Mock-Instanz der MonopolyApp
|
||||||
|
app = spy(new MonopolyApp());
|
||||||
|
|
||||||
|
// Mock GuiNode
|
||||||
|
guiNodeMock = mock(Node.class);
|
||||||
|
doReturn(guiNodeMock).when(app).getGuiNode();
|
||||||
|
|
||||||
|
// Initialisiere die App
|
||||||
|
doNothing().when(app).simpleInitApp();
|
||||||
app.simpleInitApp();
|
app.simpleInitApp();
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T001: UC-game-01 - Überprüft, ob die Anwendung erfolgreich gestartet wird und das Hauptmenü angezeigt wird
|
// T001: UC-game-01 - Überprüft, ob die Anwendung erfolgreich gestartet wird und das Hauptmenü angezeigt wird
|
||||||
public void testStartApplication() {
|
public void testStartApplication() {
|
||||||
|
// Mock des Hauptmenü-Kindes
|
||||||
|
Spatial mainMenuMock = mock(Spatial.class);
|
||||||
|
when(guiNodeMock.getChild("MainMenu")).thenReturn(mainMenuMock);
|
||||||
|
|
||||||
|
// Test, ob das Hauptmenü angezeigt wird
|
||||||
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
|
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
|
||||||
assertNotNull("Das Hauptmenü sollte sichtbar sein", mainMenu);
|
assertNotNull("Das Hauptmenü sollte sichtbar sein", mainMenu);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
// T002: UC-game-02 - Überprüft, ob das Startmenü nach dem Start der Anwendung angezeigt wird
|
||||||
|
public void testOpenStartMenu() {
|
||||||
|
// Mock des Startmenü-Kindes
|
||||||
|
Spatial startMenuMock = mock(Spatial.class);
|
||||||
|
when(guiNodeMock.getChild("StartMenu")).thenReturn(startMenuMock);
|
||||||
|
|
||||||
|
// Test, ob das Startmenü angezeigt wird
|
||||||
|
Spatial startMenu = app.getGuiNode().getChild("StartMenu");
|
||||||
|
assertNotNull("Das Startmenü sollte sichtbar sein", startMenu);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
// T003: UC-game-03 - Überprüft, ob der „Spiel starten“-Button das Spielerstellungsmenü öffnet
|
||||||
|
public void testNavigateToPlayOption() {
|
||||||
|
// Mock des Spielerstellungsmenü-Kindes
|
||||||
|
Spatial playMenuMock = mock(Spatial.class);
|
||||||
|
when(guiNodeMock.getChild("PlayMenu")).thenReturn(playMenuMock);
|
||||||
|
|
||||||
|
// Test, ob das Spielerstellungsmenü angezeigt wird
|
||||||
|
Spatial playMenu = app.getGuiNode().getChild("PlayMenu");
|
||||||
|
assertNotNull("Das Spielerstellungsmenü sollte sichtbar sein", playMenu);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
// T004: UC-game-04 - Testet, ob die Anwendung geschlossen wird, wenn „Beenden“ im Hauptmenü gewählt wird
|
||||||
|
public void testExitApplicationFromMenu() {
|
||||||
|
// Simuliere den Schließen-Aufruf
|
||||||
|
doNothing().when(app).closeApp();
|
||||||
|
|
||||||
|
// Rufe die Schließen-Methode auf
|
||||||
|
app.closeApp();
|
||||||
|
|
||||||
|
// Verifiziere, dass die Methode aufgerufen wurde
|
||||||
|
verify(app, times(1)).closeApp();
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
// T005: UC-game-05 - Überprüft, ob das Einstellungen-Menü aus dem Hauptmenü aufgerufen werden kann
|
||||||
|
public void testOpenSettingsFromMenu() {
|
||||||
|
// Mock des Einstellungsmenü-Kindes
|
||||||
|
Spatial settingsMenuMock = mock(Spatial.class);
|
||||||
|
when(guiNodeMock.getChild("SettingsMenu")).thenReturn(settingsMenuMock);
|
||||||
|
|
||||||
|
// Test, ob das Einstellungsmenü angezeigt wird
|
||||||
|
Spatial settingsMenu = app.getGuiNode().getChild("SettingsMenu");
|
||||||
|
assertNotNull("Das Einstellungsmenü sollte sichtbar sein", settingsMenu);
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
// T006: UC-game-06 - Testet, ob das Spielmenü geöffnet wird, wenn der Spieler im Spiel „ESC“ drückt
|
||||||
|
public void testOpenGameMenuWithESC() {
|
||||||
|
// Simuliere den ESC-Tastendruck
|
||||||
|
doNothing().when(app).handleEscape(true);
|
||||||
|
|
||||||
|
// Rufe die ESC-Tastenmethode auf
|
||||||
|
app.handleEscape(true);
|
||||||
|
|
||||||
|
// Verifiziere, dass die Methode aufgerufen wurde
|
||||||
|
verify(app, times(1)).handleEscape(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
/*
|
/*
|
||||||
@Test
|
@Test
|
||||||
// T002: UC-game-02 - Überprüft, ob das Startmenü nach dem Start der Anwendung angezeigt wird
|
// T002: UC-game-02 - Überprüft, ob das Startmenü nach dem Start der Anwendung angezeigt wird
|
||||||
@ -33,6 +109,7 @@ public class ClientLogicTest {
|
|||||||
assertNotNull("Das Startmenü sollte sichtbar sein", startMenu);
|
assertNotNull("Das Startmenü sollte sichtbar sein", startMenu);
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
|
/*
|
||||||
@Test
|
@Test
|
||||||
// T002: UC-game-02 - Überprüft, ob das Startmenü (MainMenu) angezeigt wird und die Buttons korrekt funktionieren
|
// T002: UC-game-02 - Überprüft, ob das Startmenü (MainMenu) angezeigt wird und die Buttons korrekt funktionieren
|
||||||
public void testMainMenuButtons() {
|
public void testMainMenuButtons() {
|
||||||
@ -159,3 +236,4 @@ public void testMainMenuButtons() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
*/
|
||||||
@ -1,606 +1,123 @@
|
|||||||
package pp.monopoly.game.client;
|
package pp.monopoly.game.client;
|
||||||
|
/*
|
||||||
import com.jme3.scene.Spatial;
|
|
||||||
import com.simsilica.lemur.Button;
|
|
||||||
import com.simsilica.lemur.TextField;
|
|
||||||
import org.junit.Before;
|
import org.junit.Before;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
import pp.monopoly.client.MonopolyApp;
|
import org.mockito.Mock;
|
||||||
import pp.monopoly.game.server.Player;
|
import org.mockito.MockitoAnnotations;
|
||||||
import pp.monopoly.message.server.DiceResult;
|
import pp.monopoly.server.MonopolyServer;
|
||||||
import pp.monopoly.notification.ClientStateEvent;
|
import pp.monopoly.client.ClientSender;
|
||||||
|
|
||||||
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertEquals;
|
||||||
import static org.junit.Assert.assertNotNull;
|
|
||||||
import static org.junit.Assert.assertTrue;
|
import static org.junit.Assert.assertTrue;
|
||||||
|
import static org.mockito.Mockito.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Tests the client-side logic of the Monopoly game.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
public class ClientGameLogicTest {
|
public class ClientGameLogicTest {
|
||||||
|
|
||||||
private MonopolyApp app;
|
private ClientGameLogic logic;
|
||||||
|
|
||||||
private MonopolyApp app;
|
@Mock
|
||||||
private NewGameMenu newGameMenu;
|
private MonopolyServer serverMock;
|
||||||
|
|
||||||
|
@Mock
|
||||||
|
private ClientSender clientSenderMock;
|
||||||
|
|
||||||
@Before
|
@Before
|
||||||
public void setUp() {
|
public void setUp() {
|
||||||
app = new MonopolyApp();
|
MockitoAnnotations.openMocks(this);
|
||||||
app.simpleInitApp(); // Initialisiert die App mit GUI und Spielzuständen
|
logic = new ClientGameLogic(clientSenderMock);
|
||||||
newGameMenu = new NewGameMenu();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T006: UC-game-06 - Testet, ob das Spielmenü geöffnet wird, wenn der Spieler im Spiel „ESC“ drückt
|
|
||||||
public void testOpenGameMenuWithESC() {
|
|
||||||
app.escape(true); // Simuliert das Drücken der ESC-Taste
|
|
||||||
|
|
||||||
Spatial gameMenu = app.getGuiNode().getChild("GameMenu");
|
|
||||||
assertNotNull("Das Spielmenü sollte sichtbar sein, nachdem ESC gedrückt wurde", gameMenu);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T007: UC-game-07 - Testet, ob der Spieler erfolgreich den Namen des Hosts eingeben kann
|
|
||||||
public void testEnterHostName() {
|
public void testEnterHostName() {
|
||||||
Spatial hostNameField = app.getGuiNode().getChild("HostNameField");
|
String hostName = "localhost";
|
||||||
assertNotNull("Das Eingabefeld für den Hostnamen sollte sichtbar sein", hostNameField);
|
logic.setHostName(hostName);
|
||||||
|
|
||||||
if (hostNameField instanceof TextField) {
|
assertEquals("The hostname should be correctly set.", hostName, logic.getHostName());
|
||||||
TextField hostNameInput = (TextField) hostNameField;
|
|
||||||
hostNameInput.setText("TestHost");
|
|
||||||
|
|
||||||
assertEquals("Der eingegebene Hostname sollte 'TestHost' sein", "TestHost", hostNameInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'HostNameField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T008: UC-game-08 - Testet, ob der Spieler die Portnummer des Hosts eingeben kann
|
|
||||||
public void testEnterPortNumber() {
|
public void testEnterPortNumber() {
|
||||||
Spatial portNumberField = app.getGuiNode().getChild("PortNumberField");
|
int portNumber = 12345;
|
||||||
assertNotNull("Das Eingabefeld für die Portnummer sollte sichtbar sein", portNumberField);
|
logic.setPortNumber(portNumber);
|
||||||
|
|
||||||
if (portNumberField instanceof TextField) {
|
assertEquals("The port number should be correctly set.", portNumber, logic.getPortNumber());
|
||||||
TextField portNumberInput = (TextField) portNumberField;
|
|
||||||
portNumberInput.setText("12345");
|
|
||||||
|
|
||||||
assertEquals("Die eingegebene Portnummer sollte '12345' sein", "12345", portNumberInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'PortNumberField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T009: UC-game-09 - Testet, ob der Spieler das Erstellen eines Spiels abbrechen kann
|
|
||||||
public void testCancelGameCreation() {
|
public void testCancelGameCreation() {
|
||||||
Spatial cancelButtonSpatial = app.getGuiNode().getChild("CancelButton");
|
doNothing().when(clientSenderMock).returnToMainMenu();
|
||||||
assertNotNull("Der 'Abbrechen'-Button sollte existieren", cancelButtonSpatial);
|
|
||||||
|
|
||||||
if (cancelButtonSpatial instanceof Button) {
|
logic.cancelGameCreation();
|
||||||
Button cancelButton = (Button) cancelButtonSpatial;
|
|
||||||
cancelButton.click();
|
|
||||||
|
|
||||||
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
|
verify(clientSenderMock, times(1)).returnToMainMenu();
|
||||||
assertNotNull("Das Hauptmenü sollte nach dem Abbrechen des Spiels sichtbar sein", mainMenu);
|
}
|
||||||
}
|
|
||||||
else {
|
@Test
|
||||||
throw new AssertionError("'CancelButton' ist kein Button-Objekt.");
|
public void testEnterPlayerLobby() {
|
||||||
}
|
doNothing().when(clientSenderMock).enterLobby();
|
||||||
|
|
||||||
|
logic.enterLobby();
|
||||||
|
|
||||||
|
verify(clientSenderMock, times(1)).enterLobby();
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
|
||||||
@Test
|
|
||||||
// T010: UC-game-10 - Testet, ob der Spieler die Spielerlobby betreten kann
|
|
||||||
public void testEnterPlayerLobby() {
|
|
||||||
app.receivedEvent(new pp.monopoly.notification.ClientStateEvent(pp.monopoly.notification.ClientStateEvent.State.LOBBY));
|
|
||||||
|
|
||||||
Spatial playerLobby = app.getGuiNode().getChild("PlayerLobby");
|
|
||||||
assertNotNull("Die Spielerlobby sollte nach dem Beitritt sichtbar sein", playerLobby);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T010: UC-game-10 - Testet, ob der Spieler die Spielerlobby betreten kann
|
|
||||||
public void testEnterPlayerLobby() {
|
|
||||||
// Simuliert den Empfang eines ClientStateEvent für den Lobby-State
|
|
||||||
app.receivedEvent(new ClientStateEvent(ClientStateEvent.State.LOBBY));
|
|
||||||
|
|
||||||
// Überprüft, ob das Lobby-UI sichtbar ist
|
|
||||||
Spatial playerLobby = app.getGuiNode().getChild("PlayerLobby");
|
|
||||||
assertNotNull("Die Spielerlobby sollte nach dem Beitritt sichtbar sein", playerLobby);
|
|
||||||
*/
|
|
||||||
@Test
|
@Test
|
||||||
// T011: UC-game-11 - Testet, ob der hostende Spieler einen Startbetrag eingeben kann
|
|
||||||
public void testEnterStartingCapital() {
|
public void testEnterStartingCapital() {
|
||||||
Spatial startingCapitalField = app.getGuiNode().getChild("StartingCapitalField");
|
int startingCapital = 1500;
|
||||||
assertNotNull("Das Eingabefeld für den Startbetrag sollte existieren", startingCapitalField);
|
logic.setStartingCapital(startingCapital);
|
||||||
|
|
||||||
if (startingCapitalField instanceof TextField) {
|
assertEquals("The starting capital should be correctly set.", startingCapital, logic.getStartingCapital());
|
||||||
TextField startingCapitalInput = (TextField) startingCapitalField;
|
|
||||||
startingCapitalInput.setText("1500");
|
|
||||||
|
|
||||||
assertEquals("Der eingegebene Startbetrag sollte '1500' sein", "1500", startingCapitalInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'StartingCapitalField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T012: UC-game-12 - Testet, ob der Spieler den Startbetrag um 100 € erhöhen kann
|
|
||||||
public void testIncreaseStartingCapital() {
|
public void testIncreaseStartingCapital() {
|
||||||
Spatial increaseButton = app.getGuiNode().getChild("IncreaseCapitalButton");
|
logic.setStartingCapital(1500);
|
||||||
assertNotNull("Der 'Erhöhen'-Button sollte existieren", increaseButton);
|
logic.increaseStartingCapital();
|
||||||
|
|
||||||
if (increaseButton instanceof Button) {
|
assertEquals("The starting capital should increase by 100.", 1600, logic.getStartingCapital());
|
||||||
Button increaseCapitalButton = (Button) increaseButton;
|
|
||||||
increaseCapitalButton.click();
|
|
||||||
|
|
||||||
Spatial startingCapitalField = app.getGuiNode().getChild("StartingCapitalField");
|
|
||||||
if (startingCapitalField instanceof TextField) {
|
|
||||||
TextField startingCapitalInput = (TextField) startingCapitalField;
|
|
||||||
assertEquals("Der Startbetrag sollte um 100 erhöht worden sein", "1600", startingCapitalInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'StartingCapitalField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'IncreaseCapitalButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T013: UC-game-13 - Testet, ob der Spieler den Startbetrag um 100 € senken kann
|
|
||||||
public void testDecreaseStartingCapital() {
|
public void testDecreaseStartingCapital() {
|
||||||
Spatial decreaseButton = app.getGuiNode().getChild("DecreaseCapitalButton");
|
logic.setStartingCapital(1500);
|
||||||
assertNotNull("Der 'Senken'-Button sollte existieren", decreaseButton);
|
logic.decreaseStartingCapital();
|
||||||
|
|
||||||
if (decreaseButton instanceof Button) {
|
assertEquals("The starting capital should decrease by 100.", 1400, logic.getStartingCapital());
|
||||||
Button decreaseCapitalButton = (Button) decreaseButton;
|
|
||||||
decreaseCapitalButton.click();
|
|
||||||
|
|
||||||
Spatial startingCapitalField = app.getGuiNode().getChild("StartingCapitalField");
|
|
||||||
if (startingCapitalField instanceof TextField) {
|
|
||||||
TextField startingCapitalInput = (TextField) startingCapitalField;
|
|
||||||
assertEquals("Der Startbetrag sollte um 100 gesenkt worden sein", "1400", startingCapitalInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'StartingCapitalField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'DecreaseCapitalButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T014: UC-game-14 - Testet, ob die Standard-Spielernamen korrekt voreingestellt sind
|
|
||||||
public void testDefaultPlayerName() {
|
public void testDefaultPlayerName() {
|
||||||
Spatial playerNameField = app.getGuiNode().getChild("PlayerNameField");
|
logic.addPlayer("Player 1");
|
||||||
assertNotNull("Das Eingabefeld für den Spielernamen sollte existieren", playerNameField);
|
|
||||||
|
|
||||||
if (playerNameField instanceof TextField) {
|
assertTrue("The player name should be correctly set.", logic.getPlayerNames().contains("Player 1"));
|
||||||
TextField playerNameInput = (TextField) playerNameField;
|
|
||||||
assertEquals("Der voreingestellte Spielername sollte 'Spieler 1' sein", "Spieler 1", playerNameInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'PlayerNameField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T015: UC-game-15 - Testet, ob der Spieler einen Anzeigenamen eingeben kann
|
|
||||||
public void testEnterDisplayName() {
|
public void testEnterDisplayName() {
|
||||||
Spatial displayNameField = app.getGuiNode().getChild("DisplayNameField");
|
String displayName = "JohnDoe";
|
||||||
assertNotNull("Das Eingabefeld für den Anzeigenamen sollte existieren", displayNameField);
|
logic.setPlayerName(displayName);
|
||||||
|
|
||||||
if (displayNameField instanceof TextField) {
|
assertEquals("The display name should be correctly set.", displayName, logic.getPlayerName());
|
||||||
TextField displayNameInput = (TextField) displayNameField;
|
|
||||||
displayNameInput.setText("MaxMustermann");
|
|
||||||
|
|
||||||
assertEquals("Der eingegebene Anzeigename sollte 'MaxMustermann' sein", "MaxMustermann", displayNameInput.getText());
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'DisplayNameField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T016: UC-game-16 - Testet, ob eine Warnung angezeigt wird, wenn ein Spieler einen bereits belegten Namen eingibt
|
|
||||||
public void testDuplicateNameEntry() {
|
public void testDuplicateNameEntry() {
|
||||||
Spatial playerNameField = app.getGuiNode().getChild("PlayerNameField");
|
logic.addPlayer("Player 1");
|
||||||
assertNotNull("Das Eingabefeld für den Spielernamen sollte existieren", playerNameField);
|
boolean result = logic.addPlayer("Player 1");
|
||||||
|
|
||||||
if (playerNameField instanceof TextField) {
|
assertTrue("Duplicate names should not be allowed.", !result);
|
||||||
TextField playerNameInput = (TextField) playerNameField;
|
|
||||||
playerNameInput.setText("Spieler 1");
|
|
||||||
app.getGuiNode().getChild("AddPlayerButton").click(); // Spieler hinzufügen
|
|
||||||
playerNameInput.setText("Spieler 1");
|
|
||||||
app.getGuiNode().getChild("AddPlayerButton").click(); // Spieler mit gleichem Namen hinzufügen
|
|
||||||
|
|
||||||
Spatial warning = app.getGuiNode().getChild("DuplicateNameWarning");
|
|
||||||
assertNotNull("Es sollte eine Warnung angezeigt werden, wenn ein Name doppelt vergeben wird", warning);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'PlayerNameField' ist kein TextField-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
// T017: UC-game-17 - Testet, ob der Spieler eine verfügbare Spielfigurfarbe auswählen kann
|
|
||||||
public void testSelectPlayerColor() {
|
public void testSelectPlayerColor() {
|
||||||
Spatial colorSelector = app.getGuiNode().getChild("ColorSelector");
|
logic.addPlayer("Player 1");
|
||||||
assertNotNull("Der Farbwähler sollte existieren", colorSelector);
|
boolean result = logic.setPlayerColor("Player 1", "Red");
|
||||||
|
|
||||||
if (colorSelector instanceof Button) {
|
assertTrue("The player should be able to select an available color.", result);
|
||||||
Button colorButton = (Button) colorSelector;
|
|
||||||
colorButton.click();
|
|
||||||
|
|
||||||
Spatial selectedColor = app.getGuiNode().getChild("SelectedColor");
|
|
||||||
assertNotNull("Die gewählte Farbe sollte sichtbar sein", selectedColor);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'ColorSelector' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T018: UC-game-18 - Testet, ob eine belegte Spielfigurfarbe nicht ausgewählt werden kann
|
|
||||||
public void testSelectOccupiedColor() {
|
|
||||||
app.getGuiNode().getChild("ColorSelectorRed").click(); // Spieler 1 wählt Rot
|
|
||||||
app.getGuiNode().getChild("AddPlayerButton").click(); // Spieler 1 hinzufügen
|
|
||||||
|
|
||||||
app.getGuiNode().getChild("ColorSelectorRed").click(); // Spieler 2 versucht Rot zu wählen
|
|
||||||
Spatial warning = app.getGuiNode().getChild("ColorOccupiedWarning");
|
|
||||||
assertNotNull("Es sollte eine Warnung angezeigt werden, wenn eine belegte Farbe ausgewählt wird", warning);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T019: UC-game-19 - Testet, ob der Spieler eine Spielfigur auswählen kann
|
|
||||||
public void testSelectPlayerToken() {
|
|
||||||
Spatial tokenSelector = app.getGuiNode().getChild("TokenSelector");
|
|
||||||
assertNotNull("Der Token-Wähler sollte existieren", tokenSelector);
|
|
||||||
|
|
||||||
if (tokenSelector instanceof Button) {
|
|
||||||
Button tokenButton = (Button) tokenSelector;
|
|
||||||
tokenButton.click();
|
|
||||||
|
|
||||||
Spatial selectedToken = app.getGuiNode().getChild("SelectedToken");
|
|
||||||
assertNotNull("Die gewählte Spielfigur sollte sichtbar sein", selectedToken);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'TokenSelector' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T020: UC-game-20 - Testet, ob eine belegte Spielfigur nicht ausgewählt werden kann
|
|
||||||
public void testSelectOccupiedToken() {
|
|
||||||
app.getGuiNode().getChild("TokenSelectorShip").click();
|
|
||||||
app.getGuiNode().getChild("AddPlayerButton").click();
|
|
||||||
|
|
||||||
app.getGuiNode().getChild("TokenSelectorShip").click();
|
|
||||||
Spatial warning = app.getGuiNode().getChild("TokenOccupiedWarning");
|
|
||||||
assertNotNull("Es sollte eine Warnung angezeigt werden, wenn eine belegte Spielfigur ausgewählt wird", warning);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T021: UC-game-14 - Überprüft, ob der Spieler zur „Spiel erstellen“-Ansicht zurückkehrt, wenn Abbrechen gedrückt wird
|
|
||||||
public void testCancelPlayerLobby() {
|
|
||||||
Spatial cancelButtonSpatial = app.getGuiNode().getChild("CancelLobbyButton");
|
|
||||||
assertNotNull("Der 'Abbrechen'-Button in der Lobby sollte existieren", cancelButtonSpatial);
|
|
||||||
|
|
||||||
if (cancelButtonSpatial instanceof Button) {
|
|
||||||
Button cancelButton = (Button) cancelButtonSpatial;
|
|
||||||
cancelButton.click();
|
|
||||||
|
|
||||||
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
|
|
||||||
assertNotNull("Das Hauptmenü sollte nach dem Abbrechen der Lobby sichtbar sein", mainMenu);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'CancelLobbyButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T022: UC-game-15 - Überprüft, ob das Spielmenü in der Lobby durch Drücken der ESC-Taste geöffnet wird
|
|
||||||
public void testOpenLobbyMenuWithESC() {
|
|
||||||
app.escape(true); // Simuliert das Drücken der ESC-Taste
|
|
||||||
|
|
||||||
Spatial lobbyMenu = app.getGuiNode().getChild("LobbyMenu");
|
|
||||||
assertNotNull("Das Lobby-Menü sollte sichtbar sein, nachdem ESC in der Lobby gedrückt wurde", lobbyMenu);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T023: UC-game-16 - Testet, ob der Spieler die Auswahl der Spielfigur bestätigen kann
|
|
||||||
public void testPlayerReadyConfirmation() {
|
|
||||||
Spatial confirmButtonSpatial = app.getGuiNode().getChild("ConfirmTokenButton");
|
|
||||||
assertNotNull("Der 'Bestätigen'-Button für die Spielfigur sollte existieren", confirmButtonSpatial);
|
|
||||||
|
|
||||||
if (confirmButtonSpatial instanceof Button) {
|
|
||||||
Button confirmButton = (Button) confirmButtonSpatial;
|
|
||||||
confirmButton.click();
|
|
||||||
|
|
||||||
Spatial readyStatus = app.getGuiNode().getChild("PlayerReadyStatus");
|
|
||||||
assertNotNull("Der Status 'Bereit' sollte angezeigt werden, nachdem die Spielfigur bestätigt wurde", readyStatus);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'ConfirmTokenButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@Test
|
|
||||||
// T024: UC-game-16 - Überprüft, ob das Spiel startet, wenn alle Spieler ihre Auswahl bestätigt haben
|
|
||||||
public void testAllPlayersReady() {
|
|
||||||
app.receivedEvent(new pp.monopoly.notification.ClientStateEvent(pp.monopoly.notification.ClientStateEvent.State.ALL_PLAYERS_READY));
|
|
||||||
|
|
||||||
Spatial gameScreen = app.getGuiNode().getChild("GameScreen");
|
|
||||||
assertNotNull("Das Spiel sollte starten, wenn alle Spieler bereit sind", gameScreen);
|
|
||||||
}
|
|
||||||
@Test
|
|
||||||
// T025: UC-game-17 - Testet, ob das Einstellungen-Menü während des Spiels geöffnet wird
|
|
||||||
public void testOpenMainGameSettings () {
|
|
||||||
app.escape(true);
|
|
||||||
|
|
||||||
Spatial settingsButton = app.getGuiNode().getChild("SettingsButton");
|
|
||||||
assertNotNull("Der 'Einstellungen'-Button sollte im Spielmenü vorhanden sein", settingsButton);
|
|
||||||
|
|
||||||
if (settingsButton instanceof Button) {
|
|
||||||
((Button) settingsButton).click();
|
|
||||||
Spatial settingsMenu = app.getGuiNode().getChild("SettingsMenu");
|
|
||||||
assertNotNull("Das Einstellungen-Menü sollte im Spiel angezeigt werden", settingsMenu);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
throw new AssertionError("'SettingsButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T026: UC-gameplay-01 - Überprüft, ob der Spieler erfolgreich würfeln kann
|
|
||||||
public void testRollDice() {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
((Button) rollDiceButton).click(); // Simuliert einen Würfelwurf
|
|
||||||
Spatial diceResult = app.getGuiNode().getChild("DiceResult");
|
|
||||||
assertNotNull("Das Ergebnis des Würfelwurfs sollte angezeigt werden", diceResult);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@Test
|
|
||||||
// T027: UC-gameplay-01 - Überprüft, ob der aktive Spieler die richtige Anzahl an Feldern basierend auf dem Wurf bewegt
|
|
||||||
public void testMovePlayerAutomatically() {
|
|
||||||
Game game = new Game(); // Initialisiert ein neues Spiel
|
|
||||||
PlayerHandler playerHandler = game.getPlayerHandler(); // Holt den PlayerHandler, der die Spieler verwaltet
|
|
||||||
|
|
||||||
Player activePlayer = playerHandler.getActivePlayer(); // Holt den aktuellen aktiven Spieler
|
|
||||||
assertNotNull("Es sollte einen aktiven Spieler geben", activePlayer);
|
|
||||||
|
|
||||||
DiceResult diceResult = game.rollDice(); // Würfelwurf simulieren
|
|
||||||
int steps = diceResult.getTotal();
|
|
||||||
|
|
||||||
int initialPosition = activePlayer.getFieldId(); // Ursprüngliche Position des aktiven Spielers
|
|
||||||
playerHandler.moveActivePlayer(steps); // Bewegt den aktiven Spieler basierend auf dem Wurf
|
|
||||||
|
|
||||||
int expectedPosition = (initialPosition + steps) % game.getGameBoard().getNumberOfFields(); // Zielposition berechnen
|
|
||||||
int newPosition = activePlayer.getFieldId();
|
|
||||||
|
|
||||||
assertEquals("Der aktive Spieler sollte sich korrekt bewegen", expectedPosition, newPosition);
|
|
||||||
|
|
||||||
// Überprüfen, dass alle anderen Spieler im WaitForTurn-State bleiben
|
|
||||||
playerHandler.getPlayers().stream()
|
|
||||||
.filter(player -> player != activePlayer)
|
|
||||||
.forEach(player -> assertTrue("Andere Spieler sollten im WaitForTurn-State sein", player.getState() instanceof WaitForTurnState));
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T028: UC-gameplay-02 - Überprüft, ob die Würfel zufällige Zahlen generieren
|
|
||||||
public void testGenerationDice() {
|
|
||||||
boolean isRandom = false;
|
|
||||||
DiceResult previousResult = null;
|
|
||||||
|
|
||||||
for (int i = 0; i < 10; i++) {
|
|
||||||
DiceResult currentResult = app.getGame().rollDice();
|
|
||||||
|
|
||||||
assertNotNull("Das Würfelergebnis sollte nicht null sein", currentResult);
|
|
||||||
assertTrue("Die Würfelzahl 1 sollte zwischen 1 und 6 liegen", currentResult.getDice1() >= 1 && currentResult.getDice1() <= 6);
|
|
||||||
assertTrue("Die Würfelzahl 2 sollte zwischen 1 und 6 liegen", currentResult.getDice2() >= 1 && currentResult.getDice2() <= 6);
|
|
||||||
|
|
||||||
if (previousResult != null && (currentResult.getDice1() != previousResult.getDice1() || currentResult.getDice2() != previousResult.getDice2())) {
|
|
||||||
isRandom = true; // Unterschiedliche Würfelwerte gefunden
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
previousResult = currentResult;
|
|
||||||
}
|
|
||||||
assertTrue("Die Würfelergebnisse sollten zufällig sein", isRandom);
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T029: UC-gameplay-03 - Überprüft, ob die richtigen Augenzahlen angezeigt werden
|
|
||||||
public void testDisplayResults() {
|
|
||||||
DiceResult result = app.getGame().rollDice();
|
|
||||||
|
|
||||||
assertNotNull("Das Würfelergebnis sollte nicht null sein", result);
|
|
||||||
assertTrue("Die Würfelzahl 1 sollte zwischen 1 und 6 liegen", result.getDice1() >= 1 && result.getDice1() <= 6);
|
|
||||||
assertTrue("Die Würfelzahl 2 sollte zwischen 1 und 6 liegen", result.getDice2() >= 1 && result.getDice2() <= 6);
|
|
||||||
assertEquals("Die Summe sollte korrekt berechnet werden", result.getDice1() + result.getDice2(), result.getTotal());
|
|
||||||
}
|
|
||||||
@Test
|
|
||||||
// T030: UC-gameplay-04 - Überprüfen, ob die Summe der Würfelergebnisse korrekt berechnet wird
|
|
||||||
public void testSumDiceResults() {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
((Button) rollDiceButton).click(); // Simuliert einen Würfelwurf
|
|
||||||
Spatial diceResult1 = app.getGuiNode().getChild("DiceResult1");
|
|
||||||
Spatial diceResult2 = app.getGuiNode().getChild("DiceResult2");
|
|
||||||
|
|
||||||
assertNotNull("Die Ergebnisse des Würfelwurfs sollten angezeigt werden", diceResult1);
|
|
||||||
assertNotNull("Die Ergebnisse des Würfelwurfs sollten angezeigt werden", diceResult2);
|
|
||||||
|
|
||||||
int result1 = Integer.parseInt(diceResult1.getUserData("value").toString());
|
|
||||||
int result2 = Integer.parseInt(diceResult2.getUserData("value").toString());
|
|
||||||
int expectedSum = result1 + result2;
|
|
||||||
|
|
||||||
Spatial sumDisplay = app.getGuiNode().getChild("DiceSum");
|
|
||||||
assertEquals("Die Summe der Würfelergebnisse sollte korrekt angezeigt werden", expectedSum, Integer.parseInt(sumDisplay.getUserData("value").toString()));
|
|
||||||
} else {
|
|
||||||
throw new AssertionError("'RollDiceButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T031: UC-gameplay-05 - Überprüfen, ob die Würfel nach dem Wurf ausgegraut werden
|
|
||||||
public void testGrayOutDiceAfterRoll() {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
((Button) rollDiceButton).click(); // Simuliert einen Würfelwurf
|
|
||||||
|
|
||||||
Spatial diceDisplay = app.getGuiNode().getChild("DiceDisplay");
|
|
||||||
assertNotNull("Die Würfelanzeige sollte nach dem Wurf sichtbar sein", diceDisplay);
|
|
||||||
|
|
||||||
boolean isGrayedOut = diceDisplay.getUserData("grayedOut");
|
|
||||||
assertTrue("Die Würfel sollten nach dem Wurf ausgegraut sein", isGrayedOut);
|
|
||||||
} else {
|
|
||||||
throw new AssertionError("'RollDiceButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T032: UC-gameplay-06 - Überprüfen, ob das Würfeln eines Paschs erkannt wird
|
|
||||||
public void testDetectDouble() {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
// Simuliert mehrere Würfe, um einen Pasch zu erkennen
|
|
||||||
for (int i = 0; i < 10; i++) {
|
|
||||||
((Button) rollDiceButton).click();
|
|
||||||
Spatial diceResult1 = app.getGuiNode().getChild("DiceResult1");
|
|
||||||
Spatial diceResult2 = app.getGuiNode().getChild("DiceResult2");
|
|
||||||
|
|
||||||
int result1 = Integer.parseInt(diceResult1.getUserData("value").toString());
|
|
||||||
int result2 = Integer.parseInt(diceResult2.getUserData("value").toString());
|
|
||||||
|
|
||||||
if (result1 == result2) {
|
|
||||||
Spatial doubleIndicator = app.getGuiNode().getChild("DoubleIndicator");
|
|
||||||
assertNotNull("Ein Pasch sollte angezeigt werden, wenn zwei identische Zahlen geworfen werden", doubleIndicator);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
throw new AssertionError("'RollDiceButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T033: UC-gameplay-06 - Überprüfen, ob der Spieler bei einem Pasch erneut würfeln darf
|
|
||||||
public void testDoubleRoll() {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
// Simuliert das Würfeln eines Paschs
|
|
||||||
((Button) rollDiceButton).click();
|
|
||||||
Spatial diceResult1 = app.getGuiNode().getChild("DiceResult1");
|
|
||||||
Spatial diceResult2 = app.getGuiNode().getChild("DiceResult2");
|
|
||||||
|
|
||||||
int result1 = Integer.parseInt(diceResult1.getUserData("value").toString());
|
|
||||||
int result2 = Integer.parseInt(diceResult2.getUserData("value").toString());
|
|
||||||
|
|
||||||
if (result1 == result2) { // Überprüft, ob ein Pasch geworfen wurde
|
|
||||||
Spatial rollAgainIndicator = app.getGuiNode().getChild("RollAgainIndicator");
|
|
||||||
assertNotNull("Der Spieler sollte bei einem Pasch erneut würfeln dürfen", rollAgainIndicator);
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
throw new AssertionError("'RollDiceButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T034: UC-gameplay-06 - Überprüfen, ob der Spieler nach dem dritten Pasch ins Gefängnis muss
|
|
||||||
public void testTripleDoubleGulag() {
|
|
||||||
int doubleCount = 0;
|
|
||||||
|
|
||||||
for (int i = 0; i < 3; i++) {
|
|
||||||
Spatial rollDiceButton = app.getGuiNode().getChild("RollDiceButton");
|
|
||||||
assertNotNull("Der 'Würfeln'-Button sollte sichtbar sein", rollDiceButton);
|
|
||||||
|
|
||||||
if (rollDiceButton instanceof Button) {
|
|
||||||
((Button) rollDiceButton).click();
|
|
||||||
Spatial diceResult1 = app.getGuiNode().getChild("DiceResult1");
|
|
||||||
Spatial diceResult2 = app.getGuiNode().getChild("DiceResult2");
|
|
||||||
|
|
||||||
int result1 = Integer.parseInt(diceResult1.getUserData("value").toString());
|
|
||||||
int result2 = Integer.parseInt(diceResult2.getUserData("value").toString());
|
|
||||||
|
|
||||||
if (result1 == result2) {
|
|
||||||
doubleCount++;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (doubleCount == 3) {
|
|
||||||
Spatial jailIndicator = app.getGuiNode().getChild("JailIndicator");
|
|
||||||
assertNotNull("Der Spieler sollte nach dem dritten Pasch ins Gefängnis gehen", jailIndicator);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
throw new AssertionError("'RollDiceButton' ist kein Button-Objekt.");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
assertTrue("Der Spieler sollte drei Paschs geworfen haben", doubleCount == 3);
|
|
||||||
}
|
|
||||||
@Test
|
|
||||||
// T035: UC-gameplay-07 - Überprüfen, ob ein Spieler für Steuerfelder korrekt belastet wird
|
|
||||||
public void testTaxFieldCharges() {
|
|
||||||
Game game = new Game();
|
|
||||||
PlayerHandler playerHandler = game.getPlayerHandler();
|
|
||||||
Player activePlayer = playerHandler.getActivePlayer();
|
|
||||||
assertNotNull("Es sollte einen aktiven Spieler geben", activePlayer);
|
|
||||||
|
|
||||||
int initialBalance = activePlayer.getAccountBalance();
|
|
||||||
|
|
||||||
activePlayer.moveToField(game.getGameBoard().getFieldById(4)); // ID 4: Steuerfeld "Diszi"
|
|
||||||
game.getGameBoard().applyFieldEffect(activePlayer);
|
|
||||||
|
|
||||||
int expectedBalance = initialBalance - 200; // Beispielsteuer: 200 €
|
|
||||||
assertEquals("Der Spieler sollte für das Steuerfeld korrekt belastet werden", expectedBalance, activePlayer.getAccountBalance());
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T036: UC-gameplay-08 - Überprüfen, ob ein Spieler korrekt ins Gefängnis geschickt wird
|
|
||||||
public void testGoToJailField() {
|
|
||||||
Game game = new Game();
|
|
||||||
PlayerHandler playerHandler = game.getPlayerHandler();
|
|
||||||
Player activePlayer = playerHandler.getActivePlayer();
|
|
||||||
assertNotNull("Es sollte einen aktiven Spieler geben", activePlayer);
|
|
||||||
|
|
||||||
activePlayer.moveToField(game.getGameBoard().getFieldById(30)); // ID 30: Ab ins Gefängnis
|
|
||||||
game.getGameBoard().applyFieldEffect(activePlayer);
|
|
||||||
|
|
||||||
assertEquals("Der Spieler sollte ins Gefängnis geschickt werden", 10, activePlayer.getFieldId()); // ID 10: Gefängnis
|
|
||||||
}
|
|
||||||
|
|
||||||
@Test
|
|
||||||
// T037: UC-gameplay-09 - Überprüfen, ob ein Spieler bei "Frei Parken" keine Gebühren zahlt
|
|
||||||
public void testFreeParking() {
|
|
||||||
Game game = new Game();
|
|
||||||
PlayerHandler playerHandler = game.getPlayerHandler();
|
|
||||||
Player activePlayer = playerHandler.getActivePlayer();
|
|
||||||
assertNotNull("Es sollte einen aktiven Spieler geben", activePlayer);
|
|
||||||
|
|
||||||
int initialBalance = activePlayer.getAccountBalance();
|
|
||||||
|
|
||||||
activePlayer.moveToField(game.getGameBoard().getFieldById(20)); // ID 20: Frei Parken
|
|
||||||
game.getGameBoard().applyFieldEffect(activePlayer);
|
|
||||||
|
|
||||||
assertEquals("Der Spieler sollte bei 'Frei Parken' keine Gebühren zahlen", initialBalance, activePlayer.getAccountBalance());
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
|
||||||
@ -2,11 +2,992 @@ package pp.monopoly.game.server;
|
|||||||
|
|
||||||
import org.junit.Before;
|
import org.junit.Before;
|
||||||
import org.junit.Test;
|
import org.junit.Test;
|
||||||
|
import org.mockito.MockedStatic;
|
||||||
|
import pp.monopoly.message.server.DiceResult;
|
||||||
|
import pp.monopoly.model.card.Card;
|
||||||
|
import pp.monopoly.model.card.DeckHelper;
|
||||||
|
import pp.monopoly.model.fields.BoardManager;
|
||||||
|
import pp.monopoly.model.fields.EventField;
|
||||||
|
import pp.monopoly.model.fields.FineField;
|
||||||
|
import pp.monopoly.model.fields.GulagField;
|
||||||
|
import pp.monopoly.model.fields.PropertyField;
|
||||||
|
import pp.monopoly.model.fields.BuildingProperty;
|
||||||
|
|
||||||
|
import java.lang.reflect.Constructor;
|
||||||
|
import java.lang.reflect.Field;
|
||||||
|
import java.util.ArrayList;
|
||||||
|
import java.util.List;
|
||||||
|
import java.util.Queue;
|
||||||
|
|
||||||
|
import static junit.framework.TestCase.assertSame;
|
||||||
import static org.junit.Assert.assertEquals;
|
import static org.junit.Assert.assertEquals;
|
||||||
|
import static org.junit.Assert.assertFalse;
|
||||||
|
import static org.junit.Assert.assertThrows;
|
||||||
|
import static org.junit.Assert.assertTrue;
|
||||||
|
import static org.mockito.ArgumentMatchers.any;
|
||||||
|
import static org.mockito.ArgumentMatchers.anyInt;
|
||||||
|
import static org.mockito.Mockito.atLeastOnce;
|
||||||
|
import static org.mockito.Mockito.doAnswer;
|
||||||
|
import static org.mockito.Mockito.doCallRealMethod;
|
||||||
|
import static org.mockito.Mockito.doNothing;
|
||||||
|
import static org.mockito.Mockito.doReturn;
|
||||||
|
import static org.mockito.Mockito.mock;
|
||||||
|
import static org.mockito.Mockito.mockStatic;
|
||||||
|
import static org.mockito.Mockito.never;
|
||||||
|
import static org.mockito.Mockito.spy;
|
||||||
|
import static org.mockito.Mockito.times;
|
||||||
|
import static org.mockito.Mockito.verify;
|
||||||
|
import static org.mockito.Mockito.when;
|
||||||
|
|
||||||
public class ServerGameLogicTest {
|
public class ServerGameLogicTest {
|
||||||
|
|
||||||
|
private ServerGameLogic serverGameLogic;
|
||||||
|
private PlayerHandler playerHandler;
|
||||||
|
private Player player;
|
||||||
|
private PropertyField property;
|
||||||
|
|
||||||
|
@Before
|
||||||
|
public void setUp() {
|
||||||
|
// Initialisierung von Abhängigkeiten
|
||||||
|
serverGameLogic = new ServerGameLogic(null, null);
|
||||||
|
playerHandler = new PlayerHandler(serverGameLogic);
|
||||||
|
player = new Player(1, "TestPlayer", playerHandler);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T026: Überprüfen, ob der Spieler erfolgreich würfeln kann.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testRollDice() {
|
||||||
|
// Act: Spieler würfelt
|
||||||
|
player = mock(Player.class);
|
||||||
|
when(player.rollDice()).thenReturn(new DiceResult(List.of(4, 3))); // Beispiel: Würfel zeigen 4 und 3
|
||||||
|
DiceResult diceResult = player.rollDice();
|
||||||
|
|
||||||
|
// Assert: Würfelwerte liegen im Bereich von 2 bis 12
|
||||||
|
assertTrue(diceResult.calcTotal() >= 2 && diceResult.calcTotal() <= 12);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T027: Überprüfen, ob der Spieler die richtige Anzahl an Feldern basierend auf dem Wurf bewegt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testMovePlayer() {
|
||||||
|
// Arrange: Spieler initialisieren und Position setzen
|
||||||
|
player.getFieldID(); // Startfeld
|
||||||
|
DiceResult diceResult = new DiceResult(List.of(3, 4)); // Würfel: 3 und 4
|
||||||
|
|
||||||
|
// Act: Spieler bewegen
|
||||||
|
int newFieldID = (player.getFieldID() + diceResult.calcTotal()) % 40; // Spielfeld mit 40 Feldern
|
||||||
|
player.move(newFieldID);
|
||||||
|
|
||||||
|
// Assert: Position überprüfen
|
||||||
|
assertEquals(newFieldID, player.getFieldID());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T028: Überprüft, ob die Würfel zufällige Zahlen generieren.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testGenerationDice() {
|
||||||
|
// Arrange: Statistiken für Würfel
|
||||||
|
int min = Integer.MAX_VALUE;
|
||||||
|
int max = Integer.MIN_VALUE;
|
||||||
|
|
||||||
|
// Act: Simuliere mehrere Würfe
|
||||||
|
for (int i = 0; i < 1000; i++) {
|
||||||
|
DiceResult diceResult = new DiceResult(List.of(
|
||||||
|
(int) (Math.random() * 6) + 1,
|
||||||
|
(int) (Math.random() * 6) + 1
|
||||||
|
));
|
||||||
|
int total = diceResult.calcTotal();
|
||||||
|
|
||||||
|
// Erfasse den minimalen und maximalen Wert
|
||||||
|
min = Math.min(min, total);
|
||||||
|
max = Math.max(max, total);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assert: Überprüfung der Zufälligkeit (Werte zwischen 2 und 12)
|
||||||
|
assertTrue(min >= 2); // Minimaler Wurf: 1 + 1
|
||||||
|
assertTrue(max <= 12); // Maximaler Wurf: 6 + 6
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T030: Überprüfen, ob die Summe der Würfelergebnisse korrekt berechnet wird.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testSumDiceResults() {
|
||||||
|
// Arrange: Teste alle möglichen Würfelkombinationen
|
||||||
|
for (int dice1 = 1; dice1 <= 6; dice1++) {
|
||||||
|
for (int dice2 = 1; dice2 <= 6; dice2++) {
|
||||||
|
// Act: Simuliere die Würfelergebnisse und berechne die Summe
|
||||||
|
DiceResult diceResult = new DiceResult(List.of(dice1, dice2));
|
||||||
|
int sum = diceResult.calcTotal();
|
||||||
|
|
||||||
|
// Assert: Überprüfe die korrekte Summe
|
||||||
|
assertEquals(dice1 + dice2, sum); // Erwartetes Ergebnis: Summe der beiden Würfel
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T031 Überprüfen, ob die Würfel nach dem Wurf ausgegraut werden
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testGrayOutDiceAfterRoll() {
|
||||||
|
//TODO
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T032: Überprüfen, ob alle Paschs (zwei identische Augenzahlen) korrekt erkannt werden.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testDetectDoubleForAllPossibleDoubles() {
|
||||||
|
// Act & Assert: Überprüfe für alle möglichen Paschs (1-1 bis 6-6)
|
||||||
|
for (int i = 1; i <= 6; i++) {
|
||||||
|
DiceResult diceResult = new DiceResult(List.of(i, i)); // Pasch mit zwei gleichen Zahlen
|
||||||
|
assertTrue("Pasch wurde nicht korrekt erkannt für " + i + "-" + i, diceResult.isDoublets());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T033: Überprüfen, ob ein Spieler bei einem Pasch erneut würfeln darf.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testDoubleRoll() {
|
||||||
|
// Arrange: Mock für Player erstellen
|
||||||
|
Player mockPlayer = mock(Player.class);
|
||||||
|
|
||||||
|
// Würfel-Ergebnis simulieren
|
||||||
|
DiceResult doubleResult = new DiceResult(List.of(6, 6));
|
||||||
|
when(mockPlayer.rollDice()).thenReturn(doubleResult); // rollDice wird gemockt
|
||||||
|
|
||||||
|
// Act: Spieler würfelt
|
||||||
|
DiceResult result = mockPlayer.rollDice();
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob Pasch erkannt wird
|
||||||
|
assertTrue(result.isDoublets()); // Pasch sollte erkannt werden
|
||||||
|
verify(mockPlayer, times(1)).rollDice(); // Sicherstellen, dass rollDice genau einmal aufgerufen wurde
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T034: Überprüfen, ob ein Spieler nach dem dritten Pasch ins Gulag kommt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testTripleDoubleGulag() {
|
||||||
|
// Arrange: Spieler-Mock erstellen
|
||||||
|
Player mockedPlayer = mock(Player.class);
|
||||||
|
|
||||||
|
// Drei aufeinanderfolgende Paschs simulieren
|
||||||
|
when(mockedPlayer.rollDice())
|
||||||
|
.thenReturn(new DiceResult(List.of(2, 2))) // Erster Pasch
|
||||||
|
.thenReturn(new DiceResult(List.of(5, 5))) // Zweiter Pasch
|
||||||
|
.thenReturn(new DiceResult(List.of(6, 6))); // Dritter Pasch
|
||||||
|
|
||||||
|
// Act: Spieler würfelt dreimal
|
||||||
|
boolean firstDouble = mockedPlayer.rollDice().isDoublets();
|
||||||
|
boolean secondDouble = mockedPlayer.rollDice().isDoublets();
|
||||||
|
boolean thirdDouble = mockedPlayer.rollDice().isDoublets();
|
||||||
|
|
||||||
|
// Spieler wird ins Jail bewegt, wenn drei Paschs gewürfelt wurden
|
||||||
|
if (firstDouble && secondDouble && thirdDouble) {
|
||||||
|
mockedPlayer.movePos(10); // Jail-Position im Spiel
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assert: Spieler ist nach dem dritten Pasch im Jail
|
||||||
|
assertTrue(firstDouble);
|
||||||
|
assertTrue(secondDouble);
|
||||||
|
assertTrue(thirdDouble);
|
||||||
|
verify(mockedPlayer, times(1)).movePos(10); // Spieler sollte genau einmal ins Jail bewegt werden
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
/**
|
||||||
|
* T035: Überprüft, ob der Spieler ein Grundstück kaufen kann.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testBuyProperty() {
|
||||||
|
// Arrange
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
PropertyField propertyField = mock(PropertyField.class);
|
||||||
|
List<PropertyField> properties = new ArrayList<>(); // Liste der Immobilien
|
||||||
|
|
||||||
|
// Simuliere das Verhalten von getProperties() und add
|
||||||
|
when(player.getProperties()).thenReturn(properties);
|
||||||
|
when(propertyField.getOwner()).thenReturn(null); // Kein Besitzer
|
||||||
|
when(propertyField.getPrice()).thenReturn(200); // Preis
|
||||||
|
when(player.getAccountBalance()).thenReturn(500); // Spieler hat genug Geld
|
||||||
|
|
||||||
|
// Act
|
||||||
|
player.buyProperty(propertyField);
|
||||||
|
|
||||||
|
// Hinzufügen der Immobilie simulieren
|
||||||
|
properties.add(propertyField);
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
verify(propertyField).setOwner(player); // Eigentümer setzen
|
||||||
|
verify(player).pay(200); // Betrag abziehen
|
||||||
|
assertTrue(properties.contains(propertyField)); // Überprüfen, ob die Immobilie hinzugefügt wurde
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T037: Überprüft, ob der Spieler in den Gulag geschickt wird.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testGoToGulag() {
|
||||||
|
// Arrange
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
GulagField gulagField = mock(GulagField.class);
|
||||||
|
|
||||||
|
// Spieler wird auf ein Ereignis gesetzt, das ihn ins Gefängnis schickt
|
||||||
|
when(player.getFieldID()).thenReturn(30); // Beispiel: Feld 30 = Gehe-ins-Gefängnis-Feld
|
||||||
|
|
||||||
|
// Act: Spieler wird ins Gefängnis geschickt
|
||||||
|
player.movePos(gulagField.getId());
|
||||||
|
|
||||||
|
// Assert: Überprüfe, ob der Spieler korrekt ins Gefängnis bewegt wurde
|
||||||
|
verify(player, times(1)).movePos(gulagField.getId());
|
||||||
|
verify(player, never()).earnMoney(anyInt()); // Spieler sollte kein Geld erhalten
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T039: Überprüft, ob der Spieler nicht mehr als vier Häuser bauen kann.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testMaxBuildHouses() {
|
||||||
|
// Arrange: Mock des BuildingProperty
|
||||||
|
BuildingProperty buildingProperty = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Setze Rückgabewerte für Methoden
|
||||||
|
when(buildingProperty.buildHouse()).thenReturn(true).thenReturn(true).thenReturn(true).thenReturn(true).thenReturn(false);
|
||||||
|
|
||||||
|
// Act: Spieler versucht mehr als 4 Häuser zu bauen
|
||||||
|
boolean firstBuild = buildingProperty.buildHouse(); // Haus 1
|
||||||
|
boolean secondBuild = buildingProperty.buildHouse(); // Haus 2
|
||||||
|
boolean thirdBuild = buildingProperty.buildHouse(); // Haus 3
|
||||||
|
boolean fourthBuild = buildingProperty.buildHouse(); // Haus 4
|
||||||
|
boolean fifthBuild = buildingProperty.buildHouse(); // Versuch, Haus 5 zu bauen
|
||||||
|
|
||||||
|
// Assert: Überprüfung, dass der fünfte Bau abgelehnt wird
|
||||||
|
assertTrue(firstBuild);
|
||||||
|
assertTrue(secondBuild);
|
||||||
|
assertTrue(thirdBuild);
|
||||||
|
assertTrue(fourthBuild);
|
||||||
|
assertFalse(fifthBuild); // Der fünfte Hausbau sollte blockiert werden
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T040: Überprüfen, ob der Spieler eine Hypothek auf ein Grundstück aufnehmen kann.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testTakeMortgage() {
|
||||||
|
// Arrange: Mock für Spieler und Grundstück
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Voraussetzungen: Spieler ist der Besitzer und Grundstück ist nicht hypothekiert
|
||||||
|
when(property.getOwner()).thenReturn(player);
|
||||||
|
when(property.isMortgaged()).thenReturn(false);
|
||||||
|
when(property.getHypo()).thenReturn(500);
|
||||||
|
|
||||||
|
// Act: Spieler nimmt Hypothek auf
|
||||||
|
property.setMortgaged(true); // Hypothek setzen
|
||||||
|
verify(property).setMortgaged(true); // Hypothek bestätigt
|
||||||
|
when(property.isMortgaged()).thenReturn(true); // Zustand simulieren
|
||||||
|
player.earnMoney(property.getHypo()); // Spieler erhält Geld
|
||||||
|
|
||||||
|
// Assert: Überprüfe die Ergebnisse
|
||||||
|
verify(player).earnMoney(500); // Spieler erhält Hypothekenwert
|
||||||
|
assertTrue(property.isMortgaged()); // Hypothek erfolgreich
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T041: UC-gameplay-12
|
||||||
|
* Überprüfen, ob eine Würfelanimation beim Würfeln ausgeführt wird.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testDiceRollAnimation() {
|
||||||
|
//TODO
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T042: UC-gameplay-13
|
||||||
|
* Überprüfen, ob der Spieler beim Betreten von Steuerfeldern Steuern zahlt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testPayTaxes() {
|
||||||
|
// Arrange: Mock für Spieler und Steuerfeld
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
FineField taxField = mock(FineField.class);
|
||||||
|
|
||||||
|
// Mocking: Stub für Steuerbetrag und Guthaben des Spielers
|
||||||
|
when(taxField.getFine()).thenReturn(200); // Steuerbetrag
|
||||||
|
when(player.getAccountBalance()).thenReturn(1000); // Spieler hat 1000 Guthaben
|
||||||
|
|
||||||
|
// Mock visit() Logik, um die Zahlung auszulösen
|
||||||
|
doAnswer(invocation -> {
|
||||||
|
FineField field = invocation.getArgument(0);
|
||||||
|
player.pay(field.getFine());
|
||||||
|
return null;
|
||||||
|
}).when(player).visit(any(FineField.class));
|
||||||
|
|
||||||
|
// Act: Spieler betritt das Steuerfeld
|
||||||
|
taxField.accept(player);
|
||||||
|
assertEquals(800, player.getAccountBalance());
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T044: UC-gameplay-14
|
||||||
|
* Überprüfen, ob der Spieler eine Ereigniskarte zieht und die entsprechende Aktion ausgeführt wird.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testDrawEventCard() {
|
||||||
|
// Arrange: Mock für Spieler und Karten
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
EventField eventField = new EventField("Ereignisfeld", 1);
|
||||||
|
|
||||||
|
// Mocking: Ereigniskarte simulieren
|
||||||
|
Card eventCard = mock(Card.class);
|
||||||
|
Queue<Card> mockCardQueue = mock(Queue.class);
|
||||||
|
|
||||||
|
// Mock DeckHelper: Simuliere Kartenstapel
|
||||||
|
try (MockedStatic<DeckHelper> mockedDeckHelper = mockStatic(DeckHelper.class)) {
|
||||||
|
mockedDeckHelper.when(DeckHelper::drawCard).thenReturn(eventCard);
|
||||||
|
|
||||||
|
// Mocking: Simuliere die Aktion der Karte
|
||||||
|
doNothing().when(eventCard).accept(any());
|
||||||
|
|
||||||
|
// Act: Spieler betritt das Ereignisfeld und zieht eine Karte
|
||||||
|
eventField.accept(player);
|
||||||
|
Card drawnCard = eventField.drawCard();
|
||||||
|
|
||||||
|
// Assert: Überprüfe die Interaktionen
|
||||||
|
verify(eventCard).accept(any()); // Aktion der Karte ausführen
|
||||||
|
assertSame(eventCard, drawnCard); // Sicherstellen, dass die gezogene Karte zurückgegeben wurde
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T043: Überprüfen, ob der Spieler die Hypothek zurückzahlt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testPayBackMortgage() {
|
||||||
|
// Arrange: Mock für Spieler und Grundstück
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Voraussetzungen: Spieler ist der Besitzer und Grundstück ist hypothekiert
|
||||||
|
when(property.getOwner()).thenReturn(player);
|
||||||
|
when(property.isMortgaged()).thenReturn(true);
|
||||||
|
when(property.getHypo()).thenReturn(500);
|
||||||
|
|
||||||
|
// Act: Spieler zahlt Hypothek zurück
|
||||||
|
int repaymentAmount = (int) Math.round(property.getHypo() * 1.1); // Hypothek + 10% Zinsen
|
||||||
|
player.pay(repaymentAmount); // Spieler zahlt zurück
|
||||||
|
verify(player).pay(repaymentAmount); // Zahlung bestätigt
|
||||||
|
property.setMortgaged(false); // Hypothek wird aufgehoben
|
||||||
|
when(property.isMortgaged()).thenReturn(false); // Zustand simulieren
|
||||||
|
|
||||||
|
// Assert: Überprüfe die Ergebnisse
|
||||||
|
verify(property).setMortgaged(false); // Hypothek aufgehoben
|
||||||
|
assertFalse(property.isMortgaged()); // Hypothekenstatus ist aufgehoben
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T045 - UC-gameplay-16
|
||||||
|
* Testet, ob der Spieler nur ein Hotel auf einem Grundstück bauen kann.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testBuildHotel() {
|
||||||
|
// Arrange: Spieler und Grundstück mocken
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
BuildingProperty buildingProperty = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Verhalten des Mocks definieren
|
||||||
|
when(buildingProperty.getOwner()).thenReturn(player); // Spieler ist der Besitzer
|
||||||
|
when(buildingProperty.buildHotel())
|
||||||
|
.thenReturn(true) // Erster Versuch: Hotel erfolgreich gebaut
|
||||||
|
.thenReturn(false); // Zweiter Versuch: Hotelbau blockiert
|
||||||
|
|
||||||
|
// Act: Spieler versucht, Hotels zu bauen
|
||||||
|
boolean firstBuildSuccess = buildingProperty.buildHotel(); // Erster Versuch
|
||||||
|
boolean secondBuildSuccess = buildingProperty.buildHotel(); // Zweiter Versuch
|
||||||
|
|
||||||
|
// Assert: Überprüfen der Ergebnisse
|
||||||
|
assertTrue(firstBuildSuccess); // Erstes Hotel sollte erlaubt sein
|
||||||
|
assertFalse(secondBuildSuccess); // Zweites Hotel sollte blockiert werden
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T046: Überprüfen, ob das Spiel korrekt zum nächsten Spieler wechselt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testSwitchTurnToNextPlayer() {
|
||||||
|
// Arrange
|
||||||
|
ServerGameLogic logic = mock(ServerGameLogic.class);
|
||||||
|
Player player1 = mock(Player.class);
|
||||||
|
Player player2 = mock(Player.class);
|
||||||
|
Player player3 = mock(Player.class);
|
||||||
|
|
||||||
|
when(player1.getId()).thenReturn(1);
|
||||||
|
when(player2.getId()).thenReturn(2);
|
||||||
|
when(player3.getId()).thenReturn(3);
|
||||||
|
|
||||||
|
// Initialisiere den PlayerHandler mit Spielern
|
||||||
|
PlayerHandler playerHandler = new PlayerHandler(logic);
|
||||||
|
playerHandler.addPlayer(player1);
|
||||||
|
playerHandler.addPlayer(player2);
|
||||||
|
playerHandler.addPlayer(player3);
|
||||||
|
|
||||||
|
// Act
|
||||||
|
Player currentPlayer = playerHandler.nextPlayer();
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertEquals(player2, currentPlayer); // Spieler 2 ist an der Reihe
|
||||||
|
assertEquals(player3, playerHandler.nextPlayer()); // Spieler 3 ist danach dran
|
||||||
|
assertEquals(player1, playerHandler.nextPlayer()); // Spieler 1 ist danach wieder dran
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T048: Überprüft, ob der Spieler korrekt die Strafzahlung entrichtet.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testPenaltyPayment() {
|
||||||
|
// Arrange: Mock für Spieler und die Strafe
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
int penaltyAmount = 300; // Beispiel-Strafbetrag
|
||||||
|
|
||||||
|
// Voraussetzungen: Der Spieler hat ein Konto mit genügend Guthaben
|
||||||
|
when(player.getAccountBalance()).thenReturn(1000);
|
||||||
|
|
||||||
|
// Act: Spieler zahlt die Strafe
|
||||||
|
player.pay(penaltyAmount);
|
||||||
|
|
||||||
|
// Assert: Überprüfe, ob der Betrag abgezogen wurde
|
||||||
|
verify(player).pay(penaltyAmount);
|
||||||
|
assertEquals(700, player.getAccountBalance() - penaltyAmount); // Neues Guthaben nach Strafzahlung
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T049: Überprüft, ob der Spieler korrekt Strafzahlungen erhält.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testReceivePenaltyPayment() {
|
||||||
|
// Arrange: Mock für den zahlenden und empfangenden Spieler
|
||||||
|
Player payingPlayer = mock(Player.class);
|
||||||
|
Player receivingPlayer = mock(Player.class);
|
||||||
|
int penaltyAmount = 200; // Beispiel-Strafbetrag
|
||||||
|
|
||||||
|
// Voraussetzungen: Der zahlende Spieler hat genug Guthaben
|
||||||
|
when(payingPlayer.getAccountBalance()).thenReturn(1000);
|
||||||
|
|
||||||
|
// Act: Strafzahlung durchführen
|
||||||
|
payingPlayer.pay(penaltyAmount);
|
||||||
|
receivingPlayer.earnMoney(penaltyAmount);
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob der Betrag korrekt abgezogen wurde
|
||||||
|
verify(payingPlayer).pay(penaltyAmount);
|
||||||
|
|
||||||
|
// Überprüfen, ob der Betrag beim Empfänger gutgeschrieben wurde
|
||||||
|
verify(receivingPlayer).earnMoney(penaltyAmount);
|
||||||
|
|
||||||
|
// Optional: Überprüfen der neuen Guthabenstände
|
||||||
|
assertEquals(800, payingPlayer.getAccountBalance() - penaltyAmount); // Neues Guthaben des zahlenden Spielers
|
||||||
|
assertEquals(200, receivingPlayer.getAccountBalance() + penaltyAmount); // Neues Guthaben des empfangenden Spielers
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T050: Überprüfen, ob der Spieler das Gulag verlassen kann.
|
||||||
|
*
|
||||||
|
* /
|
||||||
|
|
||||||
|
@Test public void testLeaveGulag() {
|
||||||
|
// Arrange: Mock für PlayerHandler
|
||||||
|
PlayerHandler handlerMock = mock(PlayerHandler.class);
|
||||||
|
Player player = new Player(1, handlerMock);
|
||||||
|
|
||||||
|
// Simuliere, dass der Spieler eine "Gulag-Frei"-Karte besitzt
|
||||||
|
player.addJailCard(); // Spieler erhält eine "Gulag-Frei"-Karte
|
||||||
|
assertEquals(1, player.getNumJailCard()); // Sicherstellen, dass die Karte vorhanden ist
|
||||||
|
|
||||||
|
// Simuliere, dass der Spieler das Gulag betritt
|
||||||
|
GulagField gulagFieldMock = mock(GulagField.class);
|
||||||
|
gulagFieldMock.accept(player); // Spieler wird in den JailState versetzt
|
||||||
|
|
||||||
|
// Act: Spieler nutzt die "Gulag-Frei"-Karte
|
||||||
|
player.useJailCard(); // Spieler verlässt das Gulag durch die Karte
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob die Karte entfernt wurde und der Spieler aktiv ist
|
||||||
|
assertEquals(0, player.getNumJailCard()); // Keine Karten mehr übrig
|
||||||
|
assertEquals(1, player.getFieldID()); // Sicherstellen, dass der Spieler nicht mehr im Gulag ist
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T051: UC-gameplay-23
|
||||||
|
* Überprüfen, ob die Spielreihenfolge korrekt bestimmt wird.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testDetermineTurnOrder() {
|
||||||
|
// Arrange: Erstellen einer Liste von Spielern mit simulierten Würfel-Ergebnissen
|
||||||
|
PlayerHandler playerHandler = new PlayerHandler(mock(ServerGameLogic.class));
|
||||||
|
Player player1 = mock(Player.class);
|
||||||
|
Player player2 = mock(Player.class);
|
||||||
|
Player player3 = mock(Player.class);
|
||||||
|
|
||||||
|
when(player1.rollDice()).thenReturn(new DiceResult(List.of(4, 3))); // Ergebnis: 7
|
||||||
|
when(player2.rollDice()).thenReturn(new DiceResult(List.of(6, 1))); // Ergebnis: 7
|
||||||
|
when(player3.rollDice()).thenReturn(new DiceResult(List.of(5, 5))); // Ergebnis: 10
|
||||||
|
|
||||||
|
playerHandler.addPlayer(player1);
|
||||||
|
playerHandler.addPlayer(player2);
|
||||||
|
playerHandler.addPlayer(player3);
|
||||||
|
|
||||||
|
// Act: Reihenfolge der Spieler bestimmen
|
||||||
|
List<Player> turnOrder = playerHandler.determineTurnOrder();
|
||||||
|
|
||||||
|
// Assert: Überprüfung, ob die Spieler in der korrekten Reihenfolge sortiert sind
|
||||||
|
assertEquals(player3, turnOrder.get(0)); // Spieler 3 hat die höchste Summe (10)
|
||||||
|
assertTrue(turnOrder.containsAll(List.of(player1, player2))); // Spieler 1 und 2 folgen
|
||||||
|
assertEquals(3, turnOrder.size()); // Überprüfung, ob alle Spieler berücksichtigt wurden
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T052: UC-gameplay-24
|
||||||
|
* Überprüfen, ob der Spieler Bankrott erklären kann.
|
||||||
|
*//*
|
||||||
|
@Test
|
||||||
|
public void testDeclareBankruptcy() {
|
||||||
|
// Arrange: Mock für Spieler, Bank und Besitz
|
||||||
|
Player player = new Player(1, "Spieler 1", mock(PlayerHandler.class));
|
||||||
|
PropertyField property1 = mock(PropertyField.class);
|
||||||
|
PropertyField property2 = mock(PropertyField.class);
|
||||||
|
List<PropertyField> properties = List.of(property1, property2);
|
||||||
|
|
||||||
|
// Spieler besitzt zwei Grundstücke und hat kein Geld mehr
|
||||||
|
player.earnMoney(500); // Spieler hat 500 auf dem Konto
|
||||||
|
when(property1.getOwner()).thenReturn(player);
|
||||||
|
when(property2.getOwner()).thenReturn(player);
|
||||||
|
player.getProperties().addAll(properties);
|
||||||
|
|
||||||
|
// Spieler hat Schulden (z. B. 1000)
|
||||||
|
int debt = 1000;
|
||||||
|
|
||||||
|
// Act: Spieler erklärt Bankrott
|
||||||
|
player.pay(debt); // Schulden abziehen
|
||||||
|
player.declareBankruptcy(); // Bankrott erklären
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob Besitz zurückgegeben wurde und Spieler bankrott ist
|
||||||
|
for (PropertyField property : properties) {
|
||||||
|
verify(property).setOwner(null); // Besitz zurück an die Bank
|
||||||
|
}
|
||||||
|
assertTrue(player.state instanceof Player.BankruptState); // Spieler ist jetzt bankrott
|
||||||
|
assertEquals(0, player.getAccountBalance()); // Spieler hat kein Geld mehr
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T053: UC-gameplay-25
|
||||||
|
* Überprüfen, ob der Spieler aufgrund eines anderen Spielers Bankrott geht.
|
||||||
|
*//*
|
||||||
|
@Test
|
||||||
|
public void testBankruptcyByPlayer() {
|
||||||
|
// Arrange: Mock für Spieler und Besitz
|
||||||
|
Player player1 = new Player(1, "Spieler 1", mock(PlayerHandler.class)); // Schuldner
|
||||||
|
Player player2 = new Player(2, "Spieler 2", mock(PlayerHandler.class)); // Gläubiger
|
||||||
|
PropertyField property1 = mock(PropertyField.class);
|
||||||
|
PropertyField property2 = mock(PropertyField.class);
|
||||||
|
List<PropertyField> properties = List.of(property1, property2);
|
||||||
|
|
||||||
|
// Spieler 1 besitzt zwei Grundstücke und hat wenig Geld
|
||||||
|
player1.earnMoney(500); // Spieler 1 hat 500 auf dem Konto
|
||||||
|
when(property1.getOwner()).thenReturn(player1);
|
||||||
|
when(property2.getOwner()).thenReturn(player1);
|
||||||
|
player1.getProperties().addAll(properties);
|
||||||
|
|
||||||
|
// Spieler 2 ist der Gläubiger
|
||||||
|
player2.earnMoney(1000); // Spieler 2 hat genug Geld
|
||||||
|
|
||||||
|
// Act: Spieler 1 zahlt an Spieler 2, bis er bankrott geht
|
||||||
|
int debt = 1000; // Spieler 1 schuldet Spieler 2 1000
|
||||||
|
player1.pay(debt);
|
||||||
|
player2.earnMoney(debt); // Spieler 2 erhält das Geld
|
||||||
|
if (player1.getAccountBalance() < 0) {
|
||||||
|
player1.declareBankruptcy();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob Spieler 1 bankrott ist und Spieler 2 das Geld erhalten hat
|
||||||
|
for (PropertyField property : properties) {
|
||||||
|
verify(property).setOwner(null); // Besitz von Spieler 1 zurück an die Bank
|
||||||
|
}
|
||||||
|
assertTrue(player1.state instanceof Player.BankruptState); // Spieler 1 ist bankrott
|
||||||
|
assertEquals(0, player1.getAccountBalance()); // Spieler 1 hat kein Geld mehr
|
||||||
|
assertEquals(1500, player2.getAccountBalance()); // Spieler 2 hat das Geld erhalten
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T054: UC-gameplay-26
|
||||||
|
* Überprüfen, ob das Spiel bei Bankrott eines Spielers mit Game Over endet.
|
||||||
|
*/
|
||||||
|
/*@Test
|
||||||
|
public void testGameOverBankruptcy() {
|
||||||
|
// Arrange: Mock für Spieler und Spiel-Logik
|
||||||
|
PlayerHandler playerHandler = mock(PlayerHandler.class);
|
||||||
|
ServerGameLogic gameLogic = mock(ServerGameLogic.class);
|
||||||
|
when(playerHandler.getLogic()).thenReturn(gameLogic);
|
||||||
|
|
||||||
|
Player player1 = new Player(1, "Spieler 1", playerHandler); // Spieler, der bankrott geht
|
||||||
|
Player player2 = new Player(2, "Spieler 2", playerHandler); // Letzter verbleibender Spieler
|
||||||
|
|
||||||
|
// Spieler in die PlayerHandler-Liste hinzufügen
|
||||||
|
List<Player> players = List.of(player1, player2);
|
||||||
|
when(playerHandler.getPlayerCount()).thenReturn(players.size());
|
||||||
|
|
||||||
|
// Spieler 1 verliert alles und erklärt Bankrott
|
||||||
|
player1.declareBankruptcy();
|
||||||
|
players.remove(player1); // Spieler 1 wird entfernt
|
||||||
|
when(playerHandler.getPlayerCount()).thenReturn(players.size() - 1);
|
||||||
|
|
||||||
|
// Act: Überprüfen, ob nur noch ein Spieler übrig ist
|
||||||
|
if (players.size() == 1) {
|
||||||
|
gameLogic.endGame(player2); // Spielende auslösen
|
||||||
|
}
|
||||||
|
|
||||||
|
// Assert: Prüfen, ob das Spiel im GameOver-Zustand ist und der Gewinner korrekt gesetzt wurde
|
||||||
|
verify(gameLogic).setGameState(GameState.GAME_OVER); // Spielstatus auf "Game Over" setzen
|
||||||
|
verify(gameLogic).endGame(player2); // Gewinner ist Spieler 2
|
||||||
|
assertTrue(player2.getAccountBalance() > 0); // Gewinner hat ein positives Guthaben
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T056: UC-gameplay-29
|
||||||
|
* Überprüfen, ob das Ereignisfeld eine zufällige Karte anzeigt und die entsprechende Aktion ausführt.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testTriggerEventTile() {
|
||||||
|
// Arrange: Mock für Spieler, Ereignisfeld und DeckHelper
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
EventField eventField = mock(EventField.class);
|
||||||
|
DeckHelper deckHelper = mock(DeckHelper.class);
|
||||||
|
Card eventCard = mock(Card.class); // Ereigniskarte
|
||||||
|
|
||||||
|
// Stubbing: Ereigniskarte ziehen
|
||||||
|
when(eventField.drawCard()).thenReturn(eventCard);
|
||||||
|
when(eventCard.getDescription()).thenReturn("Du bekommst 200€!"); // Beispieltext
|
||||||
|
|
||||||
|
// Stubbing: Spieleraktion durch Ereigniskarte
|
||||||
|
doAnswer(invocation -> {
|
||||||
|
player.earnMoney(200); // Aktion: Geld dem Spieler gutschreiben
|
||||||
|
return null;
|
||||||
|
}).when(eventCard).accept(any());
|
||||||
|
|
||||||
|
// Act: Spieler betritt das Ereignisfeld
|
||||||
|
eventField.accept(player); // Spieler interagiert mit dem Ereignisfeld
|
||||||
|
Card drawnCard = eventField.drawCard(); // Ereigniskarte wird gezogen
|
||||||
|
drawnCard.accept(deckHelper); // Ereigniskarte führt ihre Aktion aus
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob die Karte korrekt angezeigt und die Aktion ausgeführt wurde
|
||||||
|
assertEquals("Du bekommst 200€!", drawnCard.getDescription()); // Überprüfung der Kartenbeschreibung
|
||||||
|
verify(player).earnMoney(200); // Überprüfung, ob dem Spieler 200€ gutgeschrieben wurden
|
||||||
|
}
|
||||||
|
/**
|
||||||
|
* T057: UC-gameplay-30
|
||||||
|
* Überprüfen, ob der Spieler beim Erreichen des Gulag-Feldes in den Gulag versetzt wird.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testTriggerGulagTransfer() {
|
||||||
|
// Arrange: Mock-Objekte erstellen
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
PlayerHandler handler = mock(PlayerHandler.class);
|
||||||
|
ServerGameLogic logic = mock(ServerGameLogic.class);
|
||||||
|
BoardManager boardManager = mock(BoardManager.class);
|
||||||
|
GulagField gulagField = mock(GulagField.class);
|
||||||
|
|
||||||
|
// Setup: Spieler-Setup mit Logik und Mock-Feld
|
||||||
|
when(handler.getLogic()).thenReturn(logic);
|
||||||
|
when(logic.getBoardManager()).thenReturn(boardManager);
|
||||||
|
|
||||||
|
// Act: Spieler interagiert mit dem Gulag-Feld
|
||||||
|
doCallRealMethod().when(player).visit(gulagField);
|
||||||
|
player.visit(gulagField); // Spieler landet auf dem Gulag-Feld
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob der Spieler in den "JailState" versetzt wird
|
||||||
|
verify(player).setState(any(Player.JailState.class));
|
||||||
|
assertTrue(player.getState() instanceof Player.JailState); // Spieler ist jetzt im JailState
|
||||||
|
}*/
|
||||||
|
/**
|
||||||
|
* T058: UC-gameplay-31
|
||||||
|
* Überprüfen, ob der Spieler eine Karte von der Bank erfolgreich kaufen kann.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testBuyCard() {
|
||||||
|
// Arrange: Mock-Objekte für Spieler und Property erstellen
|
||||||
|
Player player = spy(new Player(1, mock(PlayerHandler.class))); // Verwenden Sie spy, um die reale Methode zu testen
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Voraussetzungen: Karte ist unbesessen und der Spieler hat genug Geld
|
||||||
|
when(property.getOwner()).thenReturn(null); // Karte gehört niemandem
|
||||||
|
when(property.getPrice()).thenReturn(1000); // Kartenpreis
|
||||||
|
when(player.getAccountBalance()).thenReturn(2000); // Spieler hat genug Geld
|
||||||
|
|
||||||
|
// Act: Spieler kauft die Karte
|
||||||
|
player.buyProperty(property);
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob der Spieler die Karte besitzt und das Geld abgezogen wurde
|
||||||
|
verify(player).pay(1000); // Geld abgezogen
|
||||||
|
verify(property).setOwner(player); // Spieler wird als Besitzer gesetzt
|
||||||
|
verify(property).getOwner(); // Prüfen, ob das Eigentümer-Attribut korrekt gesetzt wurde
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T059: UC-gameplay-32
|
||||||
|
* Überprüfen, ob der Kartenerwerb fehlschlägt, wenn der Spieler nicht genug Geld hat.
|
||||||
|
*/
|
||||||
|
/*@Test
|
||||||
|
public void testCardPurchaseFailed() {
|
||||||
|
// Arrange: Mock-Objekte für Spieler und Property erstellen
|
||||||
|
Player player = spy(new Player(1, mock(PlayerHandler.class))); // Spy verwendet für reale Methoden
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class);
|
||||||
|
|
||||||
|
// Voraussetzungen: Karte gehört der Bank und Spieler hat zu wenig Geld
|
||||||
|
when(property.getOwner()).thenReturn(null); // Karte gehört der Bank
|
||||||
|
when(property.getPrice()).thenReturn(1000); // Preis der Karte
|
||||||
|
when(player.getAccountBalance()).thenReturn(500); // Spieler hat zu wenig Geld
|
||||||
|
|
||||||
|
// Act & Assert: Spieler versucht, die Karte zu kaufen
|
||||||
|
Exception exception = assertThrows(IllegalStateException.class, () -> {
|
||||||
|
player.buyProperty(property); // Kaufversuch
|
||||||
|
});
|
||||||
|
|
||||||
|
// Überprüfen, ob die erwartete Ausnahme mit der korrekten Nachricht ausgelöst wurde
|
||||||
|
assertEquals("Property cannot be purchased", exception.getMessage());
|
||||||
|
|
||||||
|
// Verifizieren, dass der Besitzer nicht geändert wurde
|
||||||
|
verify(property, never()).setOwner(player); // Spieler darf nicht als Besitzer gesetzt werden
|
||||||
|
|
||||||
|
// Verifizieren, dass kein Geld abgezogen wurde
|
||||||
|
verify(player, never()).pay(anyInt());
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T60: Überprüfen, ob der Spieler korrekt Miete zahlt, wenn er auf einem besetzten Grundstück landet.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testPayRent() {
|
||||||
|
// Arrange: Erstelle Mock-Objekte für Spieler und Grundstück
|
||||||
|
Player tenant = spy(new Player(1, mock(PlayerHandler.class))); // Spieler, der die Miete zahlt
|
||||||
|
Player owner = spy(new Player(2, mock(PlayerHandler.class))); // Spieler, der die Miete erhält
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class); // Grundstück
|
||||||
|
|
||||||
|
// Voraussetzungen:
|
||||||
|
when(property.getOwner()).thenReturn(owner); // Eigentümer des Grundstücks
|
||||||
|
when(property.calcRent()).thenReturn(300); // Berechnete Miete beträgt 300
|
||||||
|
when(tenant.getAccountBalance()).thenReturn(1000); // Mieter hat 1000 Guthaben
|
||||||
|
when(owner.getAccountBalance()).thenReturn(2000); // Vermieter hat 2000 Guthaben
|
||||||
|
|
||||||
|
// Act: Spieler besucht das Grundstück
|
||||||
|
property.accept(tenant);
|
||||||
|
|
||||||
|
// Assert: Überprüfen, ob die Miete korrekt verarbeitet wurde
|
||||||
|
verify(tenant).pay(300); // Spieler zahlt 300
|
||||||
|
verify(owner).earnMoney(300); // Eigentümer erhält 300
|
||||||
|
assertEquals(700, tenant.getAccountBalance()); // Mieter hat noch 700 übrig
|
||||||
|
assertEquals(2300, owner.getAccountBalance()); // Vermieter hat jetzt 2300
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T61: Überprüfen, ob der Spieler bei fehlendem Guthaben die Miete nicht zahlen kann.
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testRentPaymentFailed() {
|
||||||
|
// Arrange: Mock-Objekte für Spieler und Grundstück
|
||||||
|
Player tenant = spy(new Player(1, mock(PlayerHandler.class))); // Spieler, der die Miete zahlen soll
|
||||||
|
Player owner = spy(new Player(2, mock(PlayerHandler.class))); // Vermieter
|
||||||
|
BuildingProperty property = mock(BuildingProperty.class); // Grundstück
|
||||||
|
|
||||||
|
// Voraussetzungen
|
||||||
|
when(property.getOwner()).thenReturn(owner); // Eigentümer des Grundstücks
|
||||||
|
when(property.calcRent()).thenReturn(300); // Berechnete Miete
|
||||||
|
when(tenant.getAccountBalance()).thenReturn(200); // Guthaben des Mieters unzureichend
|
||||||
|
when(owner.getAccountBalance()).thenReturn(2000); // Guthaben des Vermieters
|
||||||
|
|
||||||
|
// Act: Spieler besucht das Grundstück
|
||||||
|
property.accept(tenant);
|
||||||
|
|
||||||
|
// Assert: Überprüfe, dass keine Zahlung stattfindet
|
||||||
|
verify(tenant, never()).pay(300); // Spieler zahlt nichts
|
||||||
|
verify(owner, never()).earnMoney(300); // Vermieter erhält nichts
|
||||||
|
assertEquals(200, tenant.getAccountBalance()); // Guthaben des Mieters bleibt unverändert
|
||||||
|
assertEquals(2000, owner.getAccountBalance()); // Guthaben des Vermieters bleibt unverändert
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T63: Überprüfen, ob der Spieler aufgrund einer Strafe eine Runde aussetzen muss.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testSkipTurnDueToPenalty() {
|
||||||
|
// Arrange
|
||||||
|
Player player = mock(Player.class);
|
||||||
|
PlayerHandler handler = mock(PlayerHandler.class);
|
||||||
|
when(handler.nextPlayer()).thenReturn(player); // Spielerwechsel simulieren
|
||||||
|
|
||||||
|
EventField penaltyField = mock(EventField.class);
|
||||||
|
ServerGameLogic logic = mock(ServerGameLogic.class);
|
||||||
|
when(penaltyField.accept(player)).then(invocation -> {
|
||||||
|
player.skipTurn(); // Spieler erhält eine Strafe und muss aussetzen
|
||||||
|
return null;
|
||||||
|
});
|
||||||
|
|
||||||
|
// Act
|
||||||
|
penaltyField.accept(player);
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
verify(player).skipTurn(); // Spieler muss Runde aussetzen
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
T68: Überprüfen, ob die Anzahl der "Gulag-Frei"-Karten nach der Verwendung korrekt abgezogen wird
|
||||||
|
*/
|
||||||
|
@Test
|
||||||
|
public void testDeductGulagFreeCard() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.addJailCard(); // Spieler besitzt eine Karte
|
||||||
|
player.addJailCard(); // Spieler besitzt zwei Karten
|
||||||
|
|
||||||
|
assertEquals(2, player.getNumJailCard()); // Sicherstellen, dass Spieler 2 Karten hat
|
||||||
|
|
||||||
|
// Act
|
||||||
|
player.removeJailCard(); // Spieler verwendet eine Karte
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertEquals(1, player.getNumJailCard()); // Anzahl der Karten sollte um 1 reduziert sein
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* T070: Überprüfen, ob der Spieler erfolgreich aus dem Gulag rauswürfeln kann.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testRollToExitGulag() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.addJailCard();
|
||||||
|
player.state = player.new JailState();
|
||||||
|
|
||||||
|
DiceResult successfulRoll = new DiceResult(List.of(3, 3)); // Doppelte gewürfelt
|
||||||
|
when(player.rollDice()).thenReturn(successfulRoll);
|
||||||
|
|
||||||
|
// Act
|
||||||
|
DiceResult rollResult = player.rollDice();
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertTrue(rollResult.isDoublets()); // Sicherstellen, dass doppelte gewürfelt wurde
|
||||||
|
assertTrue(player.state instanceof Player.ActiveState); // Spieler ist jetzt aktiv
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T071: Überprüfen, ob das Rauswürfeln aus dem Gulag fehlschlägt.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testFailRollToExitGulag() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.state = player.new JailState();
|
||||||
|
|
||||||
|
DiceResult unsuccessfulRoll = new DiceResult(List.of(1, 2)); // Keine Doppel
|
||||||
|
when(player.rollDice()).thenReturn(unsuccessfulRoll);
|
||||||
|
|
||||||
|
// Act
|
||||||
|
DiceResult rollResult = player.rollDice();
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertFalse(rollResult.isDoublets()); // Sicherstellen, dass keine Doppel gewürfelt wurden
|
||||||
|
assertTrue(player.state instanceof Player.JailState); // Spieler bleibt im Gulag
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T072: Überprüfen, ob der Spieler durch Zahlung erfolgreich das Gulag verlassen kann.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testPayToExitGulag() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.state = player.new JailState();
|
||||||
|
player.earnMoney(500); // Spieler hat genug Geld
|
||||||
|
|
||||||
|
// Act
|
||||||
|
player.payBail();
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertTrue(player.state instanceof Player.ActiveState); // Spieler ist jetzt aktiv
|
||||||
|
assertEquals(0, player.getAccountBalance()); // Geld korrekt abgezogen
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T073: Überprüfen, ob der Ausstieg aus dem Gulag durch Zahlung fehlschlägt, wenn nicht genug Geld vorhanden ist.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testFailPayToExitGulag() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.state = player.new JailState();
|
||||||
|
player.pay(100); // Spieler hat kein Geld mehr
|
||||||
|
|
||||||
|
// Act & Assert
|
||||||
|
assertThrows(IllegalStateException.class, () -> player.payBail());
|
||||||
|
assertTrue(player.state instanceof Player.JailState); // Spieler bleibt im Gulag
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
/**
|
||||||
|
* T074: Überprüfen, ob der Spieler eine "Gulag-Frei"-Karte erfolgreich nutzen kann.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testUseGulagFreeCardToExit() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.state = player.new JailState();
|
||||||
|
player.addJailCard(); // Spieler besitzt eine Karte
|
||||||
|
|
||||||
|
// Act
|
||||||
|
player.useJailCard();
|
||||||
|
|
||||||
|
// Assert
|
||||||
|
assertEquals(0, player.getNumJailCard()); // Karte wurde verbraucht
|
||||||
|
assertTrue(player.state instanceof Player.ActiveState); // Spieler ist jetzt aktiv
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
/**
|
||||||
|
* T075: Überprüfen, ob der Spieler das Gulag nicht verlassen kann, wenn keine "Gulag-Frei"-Karten verfügbar sind.
|
||||||
|
*/
|
||||||
|
/*
|
||||||
|
@Test
|
||||||
|
public void testFailUseGulagFreeCardToExit() {
|
||||||
|
// Arrange
|
||||||
|
Player player = new Player(1, mock(PlayerHandler.class));
|
||||||
|
player.state = player.new JailState();
|
||||||
|
|
||||||
|
// Act & Assert
|
||||||
|
assertThrows(IllegalStateException.class, () -> player.useJailCard());
|
||||||
|
assertTrue(player.state instanceof Player.JailState); // Spieler bleibt im Gulag
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
}
|
}
|
||||||
Loading…
Reference in New Issue
Block a user