peet/Gruppe-02-clone
1
0
Fork 0
mirror of https://athene2.informatik.unibw-muenchen.de/progproj/gruppen-ht24/Gruppe-02.git synced 2024-11-29 04:19:44 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'Testhandbuch' into 'main'

Browse Source 
newest version of tests

See merge request progproj/gruppen-ht24/Gruppe-02!15
This commit is contained in:
Johannes Schmelz 2024-11-25 04:34:06 +00:00
commit f67ce6be44
13 changed files with 1168 additions and 566 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java
View File

@ -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
*/

21
Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy
View File

@ -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
}

1
Projekte/monopoly/client/build.gradle
View File

@ -7,6 +7,7 @@ description = 'Monopoly Client'
dependencies {
implementation project(":jme-common")
implementation project(":monopoly:model")
implementation project(":monopoly:server")
implementation libs.jme3.desktop

1
Projekte/monopoly/client/src/main/java/pp/monopoly/client/MonopolyApp.java
View File

@ -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
Projekte/monopoly/model/build.gradle
View File

@ -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")
}

9
Projekte/monopoly/model/src/main/java/pp/monopoly/MonopolyConfig.java
View File

@ -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.

8
Projekte/monopoly/model/src/main/java/pp/monopoly/game/server/Player.java
View File

@ -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'");
}
}
}

2
Projekte/monopoly/model/src/main/java/pp/monopoly/model/card/Card.java
View File

@ -13,7 +13,7 @@ public class Card {
visitor.visit(this);
}
String getDescription() {
public String getDescription() {
return description;
}

2
Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java
View File

@ -1,3 +1,4 @@
/*
package pp.monopoly;
import org.junit.Test;
import static org.junit.Assert.assertNotNull;
@ -383,3 +384,4 @@ public class Testhandbuch {
}
*/

88
Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java
View File

@ -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.");
}
}
}
}
*/

597
Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java
View File

@ -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);
}
}
*/

983
Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java
View File

@ -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
}
*/
}

2
Projekte/monopoly/server/src/main/java/pp/monopoly/server/MonopolyServer.java
View File

@ -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);