mirror of
https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git
synced 2025-10-26 16:18:24 +01:00
Merge branch 'Testhandbuch' into 'main'
newest version of tests See merge request progproj/gruppen-ht24/Gruppe-02!15
This commit is contained in:
Johannes Schmelz
@@ -7,22 +7,21 @@
|
||||
|
||||
package pp.battleship.client;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.prefs.Preferences;
|
||||
|
||||
import com.simsilica.lemur.Button;
|
||||
import com.simsilica.lemur.Checkbox;
|
||||
import com.simsilica.lemur.Label;
|
||||
import com.simsilica.lemur.style.ElementId;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import pp.battleship.client.gui.GameMusic;
|
||||
import pp.battleship.client.gui.VolumeSlider;
|
||||
import pp.dialog.Dialog;
|
||||
import pp.dialog.StateCheckboxModel;
|
||||
import pp.dialog.TextInputDialog;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.prefs.Preferences;
|
||||
|
||||
import static pp.battleship.Resources.lookup;
|
||||
import static pp.util.PreferencesUtils.getPreferences;
|
||||
|
||||
/**
|
||||
@@ -39,7 +38,7 @@ class Menu extends Dialog {
|
||||
private final VolumeSlider slider;
|
||||
|
||||
/**
|
||||
* Constructs the Menu dialog for the Battleship application.
|
||||
* Constructs the Menu dialog for the Battleship application.+
|
||||
*
|
||||
* @param app the BattleshipApp instance
|
||||
*/
|
||||
|
||||
@@ -61,6 +61,22 @@ selector("container", "pp") {
|
||||
background.setColor(bgColor)
|
||||
}
|
||||
|
||||
selector("toolbar") {
|
||||
// Set the grey background
|
||||
background = new QuadBackgroundComponent(greyBackground)
|
||||
|
||||
// Add a red border using a TbtQuadBackgroundComponent
|
||||
def redBorder = TbtQuadBackgroundComponent.create(
|
||||
texture(name: "/com/simsilica/lemur/icons/bordered-gradient.png",
|
||||
generateMips: false),
|
||||
1, 1, 1, 1, 1,
|
||||
1f, false)
|
||||
redBorder.color = redBorderColor
|
||||
background = greyBackground
|
||||
|
||||
// Optional: Set padding inside the toolbar
|
||||
insets = new Insets3f(10, 10, 10, 10)
|
||||
}
|
||||
selector("slider", "pp") {
|
||||
background = gradient.clone()
|
||||
background.setColor(bgColor)
|
||||
@@ -190,6 +206,7 @@ selector("slider.down.button", "pp") {
|
||||
|
||||
selector("checkbox", "pp") {
|
||||
color = buttonEnabledColor
|
||||
fontSize = 20
|
||||
}
|
||||
|
||||
selector("rollup", "pp") {
|
||||
@@ -213,3 +230,7 @@ selector("tab.button", "pp") {
|
||||
|
||||
buttonCommands = stdButtonCommands
|
||||
}
|
||||
selector("settings-title", "pp") {
|
||||
fontSize = 48 // Set font size
|
||||
background = new QuadBackgroundComponent(color(0.4157f, 0.4235f, 0.4392f, 1.0f)) // Grey background
|
||||
}
|
||||
@@ -7,6 +7,7 @@ description = 'Monopoly Client'
|
||||
dependencies {
|
||||
implementation project(":jme-common")
|
||||
implementation project(":monopoly:model")
|
||||
implementation project(":monopoly:server")
|
||||
|
||||
implementation libs.jme3.desktop
|
||||
|
||||
|
||||
@@ -11,6 +11,7 @@ import com.jme3.input.controls.ActionListener;
|
||||
import com.jme3.input.controls.KeyTrigger;
|
||||
import com.jme3.system.AppSettings;
|
||||
import com.simsilica.lemur.GuiGlobals;
|
||||
import com.simsilica.lemur.Label;
|
||||
import com.simsilica.lemur.style.BaseStyles;
|
||||
|
||||
import pp.dialog.DialogBuilder;
|
||||
|
||||
@@ -7,4 +7,9 @@ description = 'Monopoly common model'
|
||||
dependencies {
|
||||
api project(":common")
|
||||
api libs.jme3.networking
|
||||
}
|
||||
testImplementation libs.mockito.core
|
||||
|
||||
testImplementation project(":monopoly:client")
|
||||
testImplementation project(":monopoly:model")
|
||||
testImplementation project(":monopoly:server")
|
||||
}
|
||||
@@ -7,13 +7,10 @@
|
||||
|
||||
package pp.monopoly;
|
||||
|
||||
import pp.util.config.Config;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import static java.lang.Math.max;
|
||||
|
||||
import pp.util.config.Config;
|
||||
|
||||
/**
|
||||
* Provides access to the configuration settings for the Monopoly game.
|
||||
* <p>
|
||||
@@ -31,7 +28,7 @@ public class MonopolyConfig extends Config {
|
||||
* The default port number for the Monopoly server.
|
||||
*/
|
||||
@Property("port")
|
||||
private int port = 1234;
|
||||
private int port = 42069;
|
||||
|
||||
/**
|
||||
* The width of the game map in terms of grid units.
|
||||
|
||||
@@ -307,7 +307,7 @@ public class Player implements FieldVisitor<Void>{
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
/**
|
||||
* Inner class for dice functionality in the game.
|
||||
* Rolls random dice values.
|
||||
*/
|
||||
@@ -438,7 +438,7 @@ public class Player implements FieldVisitor<Void>{
|
||||
getOutOfJailCard--;
|
||||
state = new ActiveState();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
private class BankruptState implements PlayerState {
|
||||
@@ -460,7 +460,7 @@ public class Player implements FieldVisitor<Void>{
|
||||
// TODO Auto-generated method stub
|
||||
throw new UnsupportedOperationException("Unimplemented method 'useJailCard'");
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
private class WaitForTurnState implements PlayerState {
|
||||
@@ -482,6 +482,6 @@ public class Player implements FieldVisitor<Void>{
|
||||
// TODO Auto-generated method stub
|
||||
throw new UnsupportedOperationException("Unimplemented method 'useJailCard'");
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@ public class Card {
|
||||
visitor.visit(this);
|
||||
}
|
||||
|
||||
String getDescription() {
|
||||
public String getDescription() {
|
||||
return description;
|
||||
}
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
/*
|
||||
package pp.monopoly;
|
||||
import org.junit.Test;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
@@ -383,3 +384,4 @@ public class Testhandbuch {
|
||||
}
|
||||
|
||||
|
||||
*/
|
||||
@@ -1,30 +1,106 @@
|
||||
package pp.monopoly.client;
|
||||
|
||||
import com.jme3.input.KeyInput;
|
||||
import com.jme3.scene.Spatial;
|
||||
import com.simsilica.lemur.Button;
|
||||
import com.jme3.scene.Node;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
public class ClientLogicTest {
|
||||
|
||||
private MonopolyApp app;
|
||||
private Node guiNodeMock;
|
||||
|
||||
@Before
|
||||
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();
|
||||
}
|
||||
|
||||
@Test
|
||||
// T001: UC-game-01 - Überprüft, ob die Anwendung erfolgreich gestartet wird und das Hauptmenü angezeigt wird
|
||||
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");
|
||||
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
|
||||
// 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);
|
||||
}
|
||||
*/
|
||||
/*
|
||||
@Test
|
||||
// T002: UC-game-02 - Überprüft, ob das Startmenü (MainMenu) angezeigt wird und die Buttons korrekt funktionieren
|
||||
public void testMainMenuButtons() {
|
||||
@@ -158,4 +235,5 @@ public void testMainMenuButtons() {
|
||||
throw new AssertionError("'ReturnButton' ist kein Button-Objekt.");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
@@ -1,606 +1,123 @@
|
||||
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.Test;
|
||||
import pp.monopoly.client.MonopolyApp;
|
||||
import pp.monopoly.game.server.Player;
|
||||
import pp.monopoly.message.server.DiceResult;
|
||||
import pp.monopoly.notification.ClientStateEvent;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.MockitoAnnotations;
|
||||
import pp.monopoly.server.MonopolyServer;
|
||||
import pp.monopoly.client.ClientSender;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
import static org.mockito.Mockito.*;
|
||||
|
||||
/**
|
||||
* Tests the client-side logic of the Monopoly game.
|
||||
*/
|
||||
/*
|
||||
public class ClientGameLogicTest {
|
||||
|
||||
private MonopolyApp app;
|
||||
private ClientGameLogic logic;
|
||||
|
||||
private MonopolyApp app;
|
||||
private NewGameMenu newGameMenu;
|
||||
@Mock
|
||||
private MonopolyServer serverMock;
|
||||
|
||||
@Mock
|
||||
private ClientSender clientSenderMock;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
app = new MonopolyApp();
|
||||
app.simpleInitApp(); // Initialisiert die App mit GUI und Spielzuständen
|
||||
newGameMenu = new NewGameMenu();
|
||||
MockitoAnnotations.openMocks(this);
|
||||
logic = new ClientGameLogic(clientSenderMock);
|
||||
}
|
||||
|
||||
@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() {
|
||||
Spatial hostNameField = app.getGuiNode().getChild("HostNameField");
|
||||
assertNotNull("Das Eingabefeld für den Hostnamen sollte sichtbar sein", hostNameField);
|
||||
String hostName = "localhost";
|
||||
logic.setHostName(hostName);
|
||||
|
||||
if (hostNameField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The hostname should be correctly set.", hostName, logic.getHostName());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T008: UC-game-08 - Testet, ob der Spieler die Portnummer des Hosts eingeben kann
|
||||
public void testEnterPortNumber() {
|
||||
Spatial portNumberField = app.getGuiNode().getChild("PortNumberField");
|
||||
assertNotNull("Das Eingabefeld für die Portnummer sollte sichtbar sein", portNumberField);
|
||||
int portNumber = 12345;
|
||||
logic.setPortNumber(portNumber);
|
||||
|
||||
if (portNumberField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The port number should be correctly set.", portNumber, logic.getPortNumber());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T009: UC-game-09 - Testet, ob der Spieler das Erstellen eines Spiels abbrechen kann
|
||||
public void testCancelGameCreation() {
|
||||
Spatial cancelButtonSpatial = app.getGuiNode().getChild("CancelButton");
|
||||
assertNotNull("Der 'Abbrechen'-Button sollte existieren", cancelButtonSpatial);
|
||||
doNothing().when(clientSenderMock).returnToMainMenu();
|
||||
|
||||
if (cancelButtonSpatial instanceof Button) {
|
||||
Button cancelButton = (Button) cancelButtonSpatial;
|
||||
cancelButton.click();
|
||||
logic.cancelGameCreation();
|
||||
|
||||
Spatial mainMenu = app.getGuiNode().getChild("MainMenu");
|
||||
assertNotNull("Das Hauptmenü sollte nach dem Abbrechen des Spiels sichtbar sein", mainMenu);
|
||||
}
|
||||
else {
|
||||
throw new AssertionError("'CancelButton' ist kein Button-Objekt.");
|
||||
}
|
||||
verify(clientSenderMock, times(1)).returnToMainMenu();
|
||||
}
|
||||
|
||||
@Test
|
||||
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
|
||||
// T011: UC-game-11 - Testet, ob der hostende Spieler einen Startbetrag eingeben kann
|
||||
public void testEnterStartingCapital() {
|
||||
Spatial startingCapitalField = app.getGuiNode().getChild("StartingCapitalField");
|
||||
assertNotNull("Das Eingabefeld für den Startbetrag sollte existieren", startingCapitalField);
|
||||
int startingCapital = 1500;
|
||||
logic.setStartingCapital(startingCapital);
|
||||
|
||||
if (startingCapitalField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The starting capital should be correctly set.", startingCapital, logic.getStartingCapital());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T012: UC-game-12 - Testet, ob der Spieler den Startbetrag um 100 € erhöhen kann
|
||||
public void testIncreaseStartingCapital() {
|
||||
Spatial increaseButton = app.getGuiNode().getChild("IncreaseCapitalButton");
|
||||
assertNotNull("Der 'Erhöhen'-Button sollte existieren", increaseButton);
|
||||
logic.setStartingCapital(1500);
|
||||
logic.increaseStartingCapital();
|
||||
|
||||
if (increaseButton instanceof Button) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The starting capital should increase by 100.", 1600, logic.getStartingCapital());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T013: UC-game-13 - Testet, ob der Spieler den Startbetrag um 100 € senken kann
|
||||
public void testDecreaseStartingCapital() {
|
||||
Spatial decreaseButton = app.getGuiNode().getChild("DecreaseCapitalButton");
|
||||
assertNotNull("Der 'Senken'-Button sollte existieren", decreaseButton);
|
||||
logic.setStartingCapital(1500);
|
||||
logic.decreaseStartingCapital();
|
||||
|
||||
if (decreaseButton instanceof Button) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The starting capital should decrease by 100.", 1400, logic.getStartingCapital());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T014: UC-game-14 - Testet, ob die Standard-Spielernamen korrekt voreingestellt sind
|
||||
public void testDefaultPlayerName() {
|
||||
Spatial playerNameField = app.getGuiNode().getChild("PlayerNameField");
|
||||
assertNotNull("Das Eingabefeld für den Spielernamen sollte existieren", playerNameField);
|
||||
logic.addPlayer("Player 1");
|
||||
|
||||
if (playerNameField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertTrue("The player name should be correctly set.", logic.getPlayerNames().contains("Player 1"));
|
||||
}
|
||||
|
||||
@Test
|
||||
// T015: UC-game-15 - Testet, ob der Spieler einen Anzeigenamen eingeben kann
|
||||
public void testEnterDisplayName() {
|
||||
Spatial displayNameField = app.getGuiNode().getChild("DisplayNameField");
|
||||
assertNotNull("Das Eingabefeld für den Anzeigenamen sollte existieren", displayNameField);
|
||||
String displayName = "JohnDoe";
|
||||
logic.setPlayerName(displayName);
|
||||
|
||||
if (displayNameField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertEquals("The display name should be correctly set.", displayName, logic.getPlayerName());
|
||||
}
|
||||
|
||||
@Test
|
||||
// T016: UC-game-16 - Testet, ob eine Warnung angezeigt wird, wenn ein Spieler einen bereits belegten Namen eingibt
|
||||
public void testDuplicateNameEntry() {
|
||||
Spatial playerNameField = app.getGuiNode().getChild("PlayerNameField");
|
||||
assertNotNull("Das Eingabefeld für den Spielernamen sollte existieren", playerNameField);
|
||||
logic.addPlayer("Player 1");
|
||||
boolean result = logic.addPlayer("Player 1");
|
||||
|
||||
if (playerNameField instanceof TextField) {
|
||||
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.");
|
||||
}
|
||||
assertTrue("Duplicate names should not be allowed.", !result);
|
||||
}
|
||||
|
||||
@Test
|
||||
// T017: UC-game-17 - Testet, ob der Spieler eine verfügbare Spielfigurfarbe auswählen kann
|
||||
public void testSelectPlayerColor() {
|
||||
Spatial colorSelector = app.getGuiNode().getChild("ColorSelector");
|
||||
assertNotNull("Der Farbwähler sollte existieren", colorSelector);
|
||||
logic.addPlayer("Player 1");
|
||||
boolean result = logic.setPlayerColor("Player 1", "Red");
|
||||
|
||||
if (colorSelector instanceof Button) {
|
||||
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());
|
||||
assertTrue("The player should be able to select an available color.", result);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
*/
|
||||
@@ -2,11 +2,992 @@ package pp.monopoly.game.server;
|
||||
|
||||
import org.junit.Before;
|
||||
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.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 {
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
}
|
||||
@@ -65,7 +65,7 @@ public class MonopolyServer implements MessageListener<HostedConnection>, Connec
|
||||
/**
|
||||
* Creates the server.
|
||||
*/
|
||||
MonopolyServer() {
|
||||
public MonopolyServer() {
|
||||
config.readFromIfExists(CONFIG_FILE);
|
||||
LOGGER.log(Level.INFO, "Configuration: {0}", config); //NON-NLS
|
||||
logic = new ServerGameLogic(this, config);
|
||||
|
||||
Reference in New Issue
Block a user