From c792a8b3fb2455d41d14f6c948c7499e7bb50d11 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Thu, 14 Nov 2024 21:54:27 +0100 Subject: [PATCH 1/7] T001 - T034 erster versuch --- .../test/java/pp/monopoly/Testhandbuch.java | 385 ++++++++++++++++++ 1 file changed, 385 insertions(+) create mode 100644 Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java new file mode 100644 index 0000000..caf2a99 --- /dev/null +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java @@ -0,0 +1,385 @@ +package pp.monopoly; +import org.junit.Test; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; +public class Testhandbuch { + + + + + + // T001 UC-game-01 - testStartApplication + @Test + public void testStartApplication() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + assertNotNull(mainMenu); + } + + // T002 UC-game-02 - testOpenStartMenu + @Test + public void testOpenStartMenu() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + mainMenu.showMenu(); + assertTrue(mainMenu.isMenuVisible()); + } + + // T003 UC-game-03 - testNavigateToPlayOption + @Test + public void testNavigateToPlayOption() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + mainMenu.showMenu(); + mainMenu.startNewGame(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + assertNotNull(newGameMenu); + } + + // T004 UC-game-04 - testExitApplicationFromMenu + @Test + public void testExitApplicationFromMenu() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + mainMenu.showMenu(); + mainMenu.exitGame(); + assertTrue(app.isClosed()); + } + + // T005 UC-game-05 - testOpenSettingsFromMenu + @Test + public void testOpenSettingsFromMenu() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + mainMenu.showMenu(); + mainMenu.openSettings(); + SettingMenu settingMenu = app.getStateManager().getState(SettingMenu.class); + assertNotNull(settingMenu); + } + + // T006 UC-game-06 - testOpenGameMenuWithESC + @Test + public void testOpenGameMenuWithESC() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + app.simpleUpdate(0.1f); + GameMenu gameMenu = app.getStateManager().getState(GameMenu.class); + assertTrue(gameMenu.isVisible()); + } + + // T007 UC-game-07 - testEnterHostName + @Test + public void testEnterHostName() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.enterHostName("localhost"); + assertEquals("localhost", newGameMenu.getHostName()); + } + + // T008 UC-game-07 - testEnterPortNumber + @Test + public void testEnterPortNumber() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.enterPortNumber(12345); + assertEquals(12345, newGameMenu.getPortNumber()); + } + + // T009 UC-game-07 - testCancelGameCreation + @Test + public void testCancelGameCreation() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.cancel(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + assertTrue(mainMenu.isMenuVisible()); + } + + // T010 UC-game-08 - testEnterPlayerLobby + @Test + public void testEnterPlayerLobby() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + app.getStateManager().getState(NetworkDialog.class).connect(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + assertNotNull(lobby); + } + + // T011 UC-game-09 - testEnterStartingCapital + @Test + public void testEnterStartingCapital() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.enterStartingCapital(1500); + assertEquals(1500, newGameMenu.getStartingCapital()); + } + + // T012 UC-game-09 - testIncreaseStartingCapital + @Test + public void testIncreaseStartingCapital() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.enterStartingCapital(1500); + newGameMenu.increaseStartingCapital(100); + assertEquals(1600, newGameMenu.getStartingCapital()); + } + + // T013 UC-game-09 - testDecreaseStartingCapital + @Test + public void testDecreaseStartingCapital() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + NewGameMenu newGameMenu = app.getStateManager().getState(NewGameMenu.class); + newGameMenu.showMenu(); + newGameMenu.enterStartingCapital(1500); + newGameMenu.decreaseStartingCapital(100); + assertEquals(1400, newGameMenu.getStartingCapital()); + } + + // T014 UC-game-10 - testDefaultPlayerName + @Test + public void testDefaultPlayerName() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + app.getStateManager().getState(Lobby.class).initializePlayerNames(); + assertEquals("Spieler 1", app.getStateManager().getState(Lobby.class).getPlayerName(0)); + assertEquals("Spieler 2", app.getStateManager().getState(Lobby.class).getPlayerName(1)); + } + + // T015 UC-game-11 - testEnterDisplayName + @Test + public void testEnterDisplayName() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.enterDisplayName("TestPlayer"); + assertEquals("TestPlayer", lobby.getPlayerName(0)); + } + + // T016 UC-game-11 - testDuplicateNameEntry + @Test + public void testDuplicateNameEntry() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.enterDisplayName("Player1"); + assertTrue(lobby.isDuplicateName("Player1")); + } + + // T017 UC-game-12 - testSelectPlayerColor + @Test + public void testSelectPlayerColor() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.selectColor("Red"); + assertEquals("Red", lobby.getPlayerColor(0)); + } + + // T018 UC-game-12 - testSelectOccupiedColor + @Test + public void testSelectOccupiedColor() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.selectColor("Red"); + assertTrue(lobby.isColorOccupied("Red")); + } + + // T019 UC-game-13 - testSelectPlayerToken + @Test + public void testSelectPlayerToken() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.selectToken("Ship"); + assertEquals("Ship", lobby.getPlayerToken(0)); + } + + // T020 UC-game-13 - testSelectOccupiedToken + @Test + public void testSelectOccupiedToken() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.selectToken("Ship"); + assertTrue(lobby.isTokenOccupied("Ship")); + } + + // T021 UC-game-14 - testCancelPlayerLobby + @Test + public void testCancelPlayerLobby() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.cancel(); + MainMenu mainMenu = app.getStateManager().getState(MainMenu.class); + assertTrue(mainMenu.isMenuVisible()); + } + + // T022 UC-game-15 - testOpenLobbyMenuWithESC + @Test + public void testOpenLobbyMenuWithESC() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + app.simpleUpdate(0.1f); + LobbyMenu lobbyMenu = app.getStateManager().getState(LobbyMenu.class); + assertTrue(lobbyMenu.isVisible()); + } + + // T023 UC-game-16 - testPlayerReadyConfirmation + @Test + public void testPlayerReadyConfirmation() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.setPlayerReady(true); + assertTrue(lobby.isPlayerReady(0)); + } + + // T024 UC-game-17 - testStartGame + @Test + public void testStartGame() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Lobby lobby = app.getStateManager().getState(Lobby.class); + lobby.startGame(); + assertEquals(GameState.InGame, lobby.getGameState()); + } + + // T025 UC-game-18 - testPlayerMovement + @Test + public void testPlayerMovement() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + player.move(5); + assertEquals(5, player.getPosition()); + } + + // T026 UC-game-19 - testPurchaseProperty + @Test + public void testPurchaseProperty() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + Property property = game.getProperty(0); + player.buyProperty(property); + assertTrue(player.getProperties().contains(property)); + } + + // T027 UC-game-20 - testMovePlayerOnDiceRoll + @Test + public void testMovePlayerOnDiceRoll() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + int initialPosition = player.getPosition(); + player.rollDice(); + assertTrue(player.getPosition() > initialPosition); + } + + // T028 UC-game-21 - testPassGo + @Test + public void testPassGo() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + player.move(40); // Assuming 40 steps moves player to Go + assertTrue(player.passedGo()); + } + + // T029 UC-game-22 - testCollectMoneyFromGo + @Test + public void testCollectMoneyFromGo() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + int initialBalance = player.getBalance(); + player.move(40); // Move to Go + assertTrue(player.getBalance() > initialBalance); + } + + // T030 UC-game-23 - testPayRent + @Test + public void testPayRent() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + PropertyField property = (PropertyField) game.getField(1); + player.move(1); + int initialBalance = player.getBalance(); + player.payRent(property); + assertTrue(player.getBalance() < initialBalance); + } + + // T031 UC-game-24 - testDeclareBankruptcy + @Test + public void testDeclareBankruptcy() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + player.declareBankruptcy(); + assertEquals(PlayerState.Bankrupt, player.getState()); + } + + // T032 UC-game-25 - testTradeProperty + @Test + public void testTradeProperty() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player1 = game.getPlayer(0); + Player player2 = game.getPlayer(1); + Property property = game.getProperty(0); + player1.offerTrade(player2, property); + assertTrue(player2.hasProperty(property)); + } + + // T033 UC-game-26 - testGameOverCondition + @Test + public void testGameOverCondition() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + player.declareBankruptcy(); + assertTrue(game.isGameOver()); + } + + // T034 UC-game-27 - testPlayerInJail + @Test + public void testPlayerInJail() { + MonopolyApp app = new MonopolyApp(); + app.simpleInitApp(); + Game game = app.getStateManager().getState(Game.class); + Player player = game.getPlayer(0); + game.sendToJail(player); + assertEquals(PlayerState.InJail, player.getState()); + } + } + + From b65f458302d01b2d07b8d6fe4a1d2e8ea88a2fd0 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Fri, 15 Nov 2024 08:42:11 +0100 Subject: [PATCH 2/7] T001 - T034 erster versuch --- .../monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java | 1 + 1 file changed, 1 insertion(+) diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java index caf2a99..36df81d 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java @@ -380,6 +380,7 @@ public class Testhandbuch { game.sendToJail(player); assertEquals(PlayerState.InJail, player.getState()); } + // T035 } From 1b4fee28538f31cddfd62ca3a014dd23b12677e2 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Fri, 15 Nov 2024 08:42:56 +0100 Subject: [PATCH 3/7] T001 - T034 erster versuch --- .../monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java | 1 + 1 file changed, 1 insertion(+) diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java index 36df81d..fac44e3 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/Testhandbuch.java @@ -381,6 +381,7 @@ public class Testhandbuch { assertEquals(PlayerState.InJail, player.getState()); } // T035 + } From f4fb04d17eee7ec7a5a8f1402e72b8b86f908277 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Fri, 15 Nov 2024 19:46:26 +0100 Subject: [PATCH 4/7] =?UTF-8?q?T001=20-=20T037=20=C3=BCberarbeitet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../pp/monopoly/client/ClientLogicTest.java | 154 +++++ .../game/client/ClientGameLogicTest.java | 606 +++++++++++++++++- 2 files changed, 750 insertions(+), 10 deletions(-) diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java index 2d19489..a25a69d 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/client/ClientLogicTest.java @@ -1,7 +1,161 @@ package pp.monopoly.client; +import com.jme3.input.KeyInput; +import com.jme3.scene.Spatial; +import com.simsilica.lemur.Button; +import org.junit.Before; import org.junit.Test; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + public class ClientLogicTest { + private MonopolyApp app; + + @Before + public void setUp() { + app = new MonopolyApp(); + app.simpleInitApp(); + } + + @Test + // T001: UC-game-01 - Überprüft, ob die Anwendung erfolgreich gestartet wird und das Hauptmenü angezeigt wird + public void testStartApplication() { + 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() { + Spatial startMenu = app.getGuiNode().getChild("StartMenu"); + 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() { + Spatial mainMenu = app.getGuiNode().getChild("MainMenu"); + assertNotNull("Das Hauptmenü (MainMenu) sollte sichtbar sein", mainMenu); + + Spatial playButtonSpatial = app.getGuiNode().getChild("PlayButton"); + assertNotNull("Der 'Spielen'-Button sollte existieren", playButtonSpatial); + + Spatial settingsButtonSpatial = app.getGuiNode().getChild("SettingsButton"); + assertNotNull("Der 'Einstellungen'-Button sollte existieren", settingsButtonSpatial); + + Spatial exitButtonSpatial = app.getGuiNode().getChild("ExitButton"); + assertNotNull("Der 'Spiel beenden'-Button sollte existieren", exitButtonSpatial); + + // Optional: Überprüfung der Funktionalität (Simulation von Button-Klicks) + if (playButtonSpatial instanceof Button) { + Button playButton = (Button) playButtonSpatial; + playButton.click(); + + Spatial newGameMenu = app.getGuiNode().getChild("NewGameMenu"); + assertNotNull("Das Spielerstellungsmenü sollte nach dem Klicken auf 'Spielen' sichtbar sein", newGameMenu); + } else { + throw new AssertionError("'PlayButton' ist kein Button-Objekt."); + } + + if (settingsButtonSpatial instanceof Button) { + Button settingsButton = (Button) settingsButtonSpatial; + settingsButton.click(); + + Spatial settingsMenu = app.getGuiNode().getChild("SettingsMenu"); + assertNotNull("Das Einstellungsmenü sollte nach dem Klicken auf 'Einstellungen' sichtbar sein", settingsMenu); + } else { + throw new AssertionError("'SettingsButton' ist kein Button-Objekt."); + } + + if (exitButtonSpatial instanceof Button) { + Button exitButton = (Button) exitButtonSpatial; + exitButton.click(); + + Spatial mainMenuAfterExit = app.getGuiNode().getChild("MainMenu"); + assertNull("Das Hauptmenü sollte nach dem Klicken auf 'Spiel beenden' nicht mehr sichtbar sein", mainMenuAfterExit); + } else { + throw new AssertionError("'ExitButton' ist kein Button-Objekt."); + } } + @Test + // T003: UC-game-03 - Überprüft, ob der „Spiel starten“-Button das Spielerstellungsmenü öffnet + public void testNavigateToPlayOption() { + Spatial startGameButtonSpatial = app.getGuiNode().getChild("StartGameButton"); + assertNotNull("Der 'Spiel starten'-Button sollte existieren", startGameButtonSpatial); + + if (startGameButtonSpatial instanceof Button) { + Button startGameButton = (Button) startGameButtonSpatial; + startGameButton.click(); + + Spatial newGameMenu = app.getGuiNode().getChild("NewGameMenu"); + assertNotNull("Das Spielerstellungsmenü sollte sichtbar sein", newGameMenu); + } else { + throw new AssertionError("'StartGameButton' ist kein Button-Objekt."); + } + } + + @Test + // T004: UC-game-04 - Testet, ob die Anwendung geschlossen wird, wenn „Beenden“ im Hauptmenü gewählt wird + public void testExitApplicationFromMenu() { + Spatial exitButtonSpatial = app.getGuiNode().getChild("ExitButton"); + assertNotNull("Der 'Beenden'-Button sollte existieren", exitButtonSpatial); + + if (exitButtonSpatial instanceof Button) { + Button exitButton = (Button) exitButtonSpatial; + exitButton.click(); + + Spatial mainMenuAfterExit = app.getGuiNode().getChild("MainMenu"); + assertNull("Das Hauptmenü sollte nach dem Beenden nicht mehr sichtbar sein", mainMenuAfterExit); + } else { + throw new AssertionError("'ExitButton' ist kein Button-Objekt."); + } + } + + @Test + // T005: UC-game-05 - Überprüft, ob das Einstellungen-Menü aus dem Hauptmenü aufgerufen werden kann + public void testOpenSettingsFromMenu() { + Spatial settingsButtonSpatial = app.getGuiNode().getChild("SettingsButton"); + assertNotNull("Der 'Einstellungen'-Button sollte existieren", settingsButtonSpatial); + + if (settingsButtonSpatial instanceof Button) { + Button settingsButton = (Button) settingsButtonSpatial; + settingsButton.click(); + + Spatial settingsMenu = app.getGuiNode().getChild("SettingsMenu"); + assertNotNull("Das Einstellungsmenü sollte sichtbar sein", settingsMenu); + } else { + throw new AssertionError("'SettingsButton' ist kein Button-Objekt."); + } + } + + @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 nach Drücken von ESC sichtbar sein", gameMenu); + + app.escape(false); // Simuliert das Loslassen der ESC-Taste + } + + + @Test + // T083: UC-menu-05 - Überprüfen, ob der Spieler erfolgreich ins Spiel zurückkehren kann + public void testReturnToGame() { + Spatial returnButtonSpatial = app.getGuiNode().getChild("ReturnButton"); + assertNotNull("Der 'Zurück'-Button sollte existieren", returnButtonSpatial); + + if (returnButtonSpatial instanceof Button) { + Button returnButton = (Button) returnButtonSpatial; + returnButton.click(); + + Spatial gameScene = app.getGuiNode().getChild("GameScene"); + assertNotNull("Die Spielszene sollte nach dem Klick auf 'Zurück' sichtbar sein", gameScene); + } else { + throw new AssertionError("'ReturnButton' ist kein Button-Objekt."); + } + } +} \ No newline at end of file diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java index 18c636f..531d6a8 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/client/ClientGameLogicTest.java @@ -1,20 +1,606 @@ -//////////////////////////////////////// -// Programming project code -// UniBw M, 2022, 2023, 2024 -// www.unibw.de/inf2 -// (c) Mark Minas (mark.minas@unibw.de) -//////////////////////////////////////// - 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 static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; public class ClientGameLogicTest { -} \ No newline at end of file + private MonopolyApp app; + + private MonopolyApp app; + private NewGameMenu newGameMenu; + + @Before + public void setUp() { + app = new MonopolyApp(); + app.simpleInitApp(); // Initialisiert die App mit GUI und Spielzuständen + newGameMenu = new NewGameMenu(); + } + + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + if (cancelButtonSpatial instanceof Button) { + Button cancelButton = (Button) cancelButtonSpatial; + cancelButton.click(); + + 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."); + } + } + + /* + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + 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."); + } + } + + @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); + + 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()); + } +} + + + From 7fce07ac1907787b321a073e80c5e563095b79b7 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Sun, 17 Nov 2024 20:00:05 +0100 Subject: [PATCH 5/7] Tests bis T070 erweitert --- .../game/server/ServerGameLogicTest.java | 568 +++++++++++++++++- 1 file changed, 562 insertions(+), 6 deletions(-) diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java index 8422cf1..2320086 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java @@ -1,12 +1,568 @@ -package pp.monopoly.game.server; - import org.junit.Before; import org.junit.Test; +import pp.monopoly.game.server.Player; +import pp.monopoly.message.server.DiceResult; +import pp.monopoly.message.server.JailEvent; +import pp.util.config.Config.Property; - -import static org.junit.Assert.assertEquals; - +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; public class ServerGameLogicTest { -} \ No newline at end of file + private Game gameMock; + private PlayerHandler playerHandlerMock; + private Player playerMock; + + @Before + public void setUp() { + gameMock = mock(Game.class); + playerHandlerMock = mock(PlayerHandler.class); + playerMock = mock(Player.class); + + when(gameMock.getPlayerHandler()).thenReturn(playerHandlerMock); + } + + @Test + // T026: UC-gameplay-01 - Überprüfen, ob der Spieler erfolgreich würfeln kann + public void testRollDice() { + DiceResult diceResult = new DiceResult(3, 4); + + when(gameMock.rollDice()).thenReturn(diceResult); + + DiceResult result = gameMock.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); + } + + @Test + // T027: UC-gameplay-01 - Überprüfen, ob der Spieler die richtige Anzahl an Feldern basierend auf dem Wurf bewegt + public void testMovePlayer() { + when(gameMock.getCurrentPlayer()).thenReturn(playerMock); + DiceResult diceResult = new DiceResult(3, 4); + when(gameMock.rollDice()).thenReturn(diceResult); + + gameMock.receivedEvent(diceResult); + + verify(playerHandlerMock).movePlayer(playerMock, diceResult.getTotal()); + } + + @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 = gameMock.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; + 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 diceResult = new DiceResult(3, 4); + + gameMock.receivedEvent(diceResult); + + assertEquals("Die Summe sollte korrekt berechnet werden", diceResult.getTotal(), diceResult.getDice1() + diceResult.getDice2()); + } + + @Test + // T030: UC-gameplay-04 - Überprüfen, ob die Summe der Würfelergebnisse korrekt berechnet wird + public void testSumDiceResults() { + DiceResult diceResult = new DiceResult(3, 5); + + gameMock.receivedEvent(diceResult); + + assertEquals("Die Summe der Würfelergebnisse sollte korrekt berechnet werden", 8, diceResult.getTotal()); + } + + @Test + // T031: UC-gameplay-05 - Überprüfen, ob die Würfel nach dem Wurf ausgegraut werden + public void testGrayOutDiceAfterRoll() { + DiceResult diceResult = new DiceResult(3, 4); + + gameMock.receivedEvent(diceResult); + + verify(gameMock).setDiceGrayedOut(true); + } + + @Test + // T032: UC-gameplay-06 - Überprüfen, ob das Würfeln eines Paschs erkannt wird + public void testDetectDouble() { + DiceResult diceResult = new DiceResult(4, 4); + + gameMock.receivedEvent(diceResult); + + verify(gameMock).handleDoubleRoll(diceResult); + } + + @Test + // T033: UC-gameplay-06 - Überprüfen, ob der Spieler bei einem Pasch erneut würfeln darf + public void testDoubleRoll() { + DiceResult diceResult = new DiceResult(6, 6); + + gameMock.receivedEvent(diceResult); + + verify(gameMock).allowExtraRoll(playerMock); + } + + @Test + // T034: UC-gameplay-06 - Überprüfen, ob der Spieler nach dem dritten Pasch ins Gulag muss + public void testTripleDoubleGulag() { + when(playerHandlerMock.getDoubleRollCount(playerMock)).thenReturn(3); + + gameMock.receivedEvent(new DiceResult(6, 6)); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.IN_JAIL); + } + + @Test + // T035: UC-gameplay-07 - Überprüfen, ob der Spieler ein Grundstück kaufen kann + public void testBuyProperty() { + Property property = new Property("TestProperty", 200, null); + BuyPropertyResponse buyResponse = new BuyPropertyResponse(true, property); + + gameMock.receivedEvent(buyResponse); + + verify(playerHandlerMock).addPropertyToPlayer(playerMock, property); + } + + @Test + // T036: UC-gameplay-08 - Überprüfen, ob der Spieler Miete an den Eigentümer zahlt + public void testPayRent() { + Player ownerMock = mock(Player.class); + Property property = new Property("TestProperty", 200, ownerMock); + PayRent payRent = new PayRent(50); + + when(gameMock.getCurrentPlayer()).thenReturn(playerMock); + + gameMock.receivedEvent(payRent); + + verify(playerMock).deductMoney(50); + verify(ownerMock).addMoney(50); + } + + @Test + // T037: UC-gameplay-09 - Überprüfen, ob der Spieler in den Gulag geschickt wird + public void testGoToGulag() { + JailEvent jailEvent = new JailEvent(); + + gameMock.receivedEvent(jailEvent); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.IN_JAIL); + } + + @Test + // T038: UC-gameplay-10 - Überprüfen, ob der Spieler Häuser auf Grundstücken bauen kann + public void testBuildHouses() { + Property property = new Property("TestProperty", 200, playerMock); + property.setHouses(2); + BuildHouses buildHousesEvent = new BuildHouses(property, 1); + + gameMock.receivedEvent(buildHousesEvent); + + assertEquals("Die Anzahl der Häuser sollte korrekt erhöht werden", 3, property.getHouses()); + verify(playerMock).deductMoney(anyInt()); + } + + @Test + // T039: UC-gameplay-10 - Überprüfen, ob der Spieler nicht mehr als vier Häuser bauen kann + public void testMaxBuildHouses() { + Property property = new Property("TestProperty", 200, playerMock); + property.setHouses(4); + BuildHouses buildHousesEvent = new BuildHouses(property, 1); + + gameMock.receivedEvent(buildHousesEvent); + + assertEquals("Die Anzahl der Häuser sollte nicht über vier hinausgehen", 4, property.getHouses()); + verify(playerMock, never()).deductMoney(anyInt()); + } + + @Test + // T040: UC-gameplay-11 - Überprüfen, ob der Spieler eine Hypothek auf ein Grundstück aufnehmen kann + public void testTakeMortgage() { + Property property = new Property("TestProperty", 200, playerMock); + TakeMortgage takeMortgageEvent = new TakeMortgage(property); + + gameMock.receivedEvent(takeMortgageEvent); + + assertTrue("Das Grundstück sollte als hypothekarisch markiert sein", property.isMortgaged()); + verify(playerMock).addMoney(anyInt()); + } + @Test + // T041: UC-gameplay-12 - Überprüfen, ob eine Würfelanimation ausgelöst wird + public void testDiceRollAnimation() { + gameMock.triggerDiceRollAnimation(playerMock); + + verify(gameMock).setDiceGrayedOut(false); + } + + @Test + // T042: UC-gameplay-13 - Überprüfen, ob Steuern korrekt berechnet und gezahlt werden + public void testPayTaxes() { + when(gameMock.getCurrentPlayer()).thenReturn(playerMock); + int taxAmount = 200; + + gameMock.receivedEvent(new TaxEvent(taxAmount)); + + verify(playerMock).deductMoney(taxAmount); + } + + @Test + // T043: UC-gameplay-14 - Überprüfen, ob die Hypothek korrekt zurückgezahlt wird + public void testPayBackMortgage() { + Property property = new Property("TestProperty", 200, playerMock); + property.setMortgaged(true); + + gameMock.receivedEvent(new PayBackMortgageEvent(property)); + + assertFalse("Die Hypothek sollte zurückgezahlt sein", property.isMortgaged()); + verify(playerMock).deductMoney(property.getMortgageValue()); + } + + @Test + // T044: UC-gameplay-15 - Überprüfen, ob eine Ereigniskarte gezogen wird + public void testDrawEventCard() { + EventCard eventCard = new EventCard("TestEvent", "Move to Go"); + + when(gameMock.drawEventCard()).thenReturn(eventCard); + + EventCard drawnCard = gameMock.drawEventCard(); + + assertNotNull("Die Ereigniskarte sollte gezogen werden", drawnCard); + assertEquals("Der Name der Karte sollte korrekt sein", "TestEvent", drawnCard.getName()); + } + + @Test + // T045: UC-gameplay-16 - Überprüfen, ob ein Spieler ein Hotel bauen kann + public void testBuildHotel() { + Property property = new Property("TestProperty", 200, playerMock); + property.setHouses(4); + + gameMock.receivedEvent(new BuildHotelEvent(property)); + + assertTrue("Das Grundstück sollte ein Hotel haben", property.hasHotel()); + verify(playerMock).deductMoney(anyInt()); + } + + @Test + // T046: UC-gameplay-17 - Überprüfen, ob der Zug korrekt zum nächsten Spieler wechselt + public void testSwitchTurnToNextPlayer() { + Player nextPlayerMock = mock(Player.class); + + when(playerHandlerMock.getNextPlayer()).thenReturn(nextPlayerMock); + + gameMock.endTurn(playerMock); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.WAIT_FOR_TURN); + verify(playerHandlerMock).setPlayerState(nextPlayerMock, PlayerState.ACTIVE); + } + + + @Test + // T047: UC-gameplay-18 - Überprüfen, ob die Kamera den aktuellen Spieler fokussiert + public void testChangeCameraFocus() { + gameMock.updateCameraFocus(playerMock); + + verify(gameMock).updateCameraFocus(playerMock); + } + + @Test + // T048: UC-gameplay-20 - Überprüfen, ob der Spieler korrekt Strafzahlungen leistet + public void testPenaltyPayment() { + int penaltyAmount = 300; + + gameMock.receivedEvent(new PenaltyEvent(penaltyAmount)); + + verify(playerMock).deductMoney(penaltyAmount); + } + + @Test + // T049: UC-gameplay-21 - Überprüfen, ob ein Spieler Strafzahlungen korrekt erhält + public void testReceivePenaltyPayment() { + Player penaltyReceiverMock = mock(Player.class); + int penaltyAmount = 300; + + gameMock.receivedEvent(new PenaltyReceivedEvent(penaltyReceiverMock, penaltyAmount)); + + verify(penaltyReceiverMock).addMoney(penaltyAmount); + } + + @Test // ??????? +// T050: UC-gameplay-22 - Überprüfen, ob ein Spieler das Gulag erfolgreich verlässt + public void testLeaveGulag() { + JailEvent leaveGulagEvent = new JailEvent(false); // false = Gulag verlassen ??? + + gameMock.receivedEvent(leaveGulagEvent); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.ACTIVE); + } + + @Test + // T051: UC-gameplay-23 - Überprüfen, ob die Spielerreihenfolge korrekt bestimmt wird + public void testDetermineTurnOrder() { + when(playerHandlerMock.determineTurnOrder()).thenReturn(true); + + boolean result = playerHandlerMock.determineTurnOrder(); + + assertTrue("Die Spielreihenfolge sollte korrekt bestimmt werden", result); + verify(playerHandlerMock).determineTurnOrder(); + } + + @Test +// T052: UC-gameplay-24 - Überprüfen, ob ein Spieler korrekt Bankrott erklärt wird + public void testDeclareBankruptcy() { + BankruptcyEvent bankruptcyEvent = new BankruptcyEvent(playerMock); + + gameMock.receivedEvent(bankruptcyEvent); + + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.BANKRUPT); + + + verify(playerHandlerMock).transferAssetsToBank(playerMock); + + + verify(gameMock, never()).updatePlayerGameState(playerMock, GameState.GAME_OVER); + } + @Test + // T053: UC-gameplay-25 - Überprüfen, ob ein Spieler durch einen anderen Spieler bankrott geht + public void testBankruptcyByPlayer() { + Player otherPlayerMock; + Property property = new Property("TestProperty", 200, otherPlayerMock); + PayRent payRentEvent = new PayRent(300); + otherPlayerMock = mock(Player.class); + + when(playerMock.getBalance()).thenReturn(200); // Spieler hat zu wenig Geld + when(gameMock.getCurrentPlayer()).thenReturn(playerMock); + + gameMock.receivedEvent(payRentEvent); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.BANKRUPT); + verify(playerHandlerMock).transferAssetsToPlayer(playerMock, otherPlayerMock); // kriegt die Bank die assets oder otherPlayer???? + } + + @Test + // T054: UC-gameplay-26 - Überprüfen, ob das Spiel endet, wenn alle Spieler bis auf einen bankrott sind + public void testGameOverBankruptcy() { + when(playerHandlerMock.getRemainingPlayersCount()).thenReturn(1); + + gameMock.checkGameOver(); + + verify(gameMock).endGame(); + } + + @Test + // T055: UC-gameplay-28 - Überprüfen, ob der Sieger korrekt angezeigt wird, wenn nur ein Spieler übrig bleibt + public void testGameOverWinner() { + when(playerHandlerMock.getRemainingPlayersCount()).thenReturn(1); + when(playerHandlerMock.getLastRemainingPlayer()).thenReturn(playerMock); + + gameMock.checkGameOver(); + + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.WINNER); + verify(gameMock).endGame(); + } + + @Test + // T056: UC-gameplay-29 - Überprüfen, ob ein Ereignisfeld eine zufällige Karte auslöst + public void testTriggerEventTile() { + EventField eventField = mock(EventField.class); + EventCard eventCard = mock(EventCard.class); + + when(eventField.drawCard()).thenReturn(eventCard); + + gameMock.triggerEventTile(eventField); + + verify(eventField).drawCard(); + verify(gameMock).applyEventCard(eventCard); //??? + } + + @Test +// T057: UC-gameplay-30 - Überprüfen, ob der Spieler beim Erreichen des Gulag-Feldes in den Gulag geschickt wird + public void testTriggerGulagTransfer() { + // Setzt die fieldId des Spielers auf das Gulag-Feld + when(playerMock.getFieldId()).thenReturn(30); + + // Simuliert das Ereignis, dass der Spieler auf ein Feld tritt + gameMock.triggerFieldAction(playerMock); + + // Überprüft, ob der Spielerzustand auf IN_JAIL gesetzt wird + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.IN_JAIL); + } + @Test + // T058: UC-gameplay-31 - Überprüfen, ob ein Spieler eine Karte kaufen kann + public void testBuyCard() { + Property property = new Property("TestProperty", 200, null); + BuyPropertyResponse buyPropertyResponse = new BuyPropertyResponse(true, property); + + gameMock.receivedEvent(buyPropertyResponse); + + verify(playerHandlerMock).addPropertyToPlayer(playerMock, property); + } + + @Test + // T059: UC-gameplay-32 - Überprüfen, ob der Kartenerwerb fehlschlägt, wenn der Spieler nicht genug Geld hat + public void testCardPurchaseFailed() { + Property property = new Property("TestProperty", 500, null); + when(playerMock.getBalance()).thenReturn(300); // Spieler hat nicht genug Geld + + BuyPropertyRequest buyPropertyRequest = new BuyPropertyRequest(property); + + gameMock.receivedEvent(buyPropertyRequest); + + verify(playerHandlerMock, never()).addPropertyToPlayer(playerMock, property); + } + + @Test + // T060: UC-gameplay-33 - Überprüfen, ob der Spieler korrekt Miete zahlt, wenn er auf einem besetzten Grundstück landet + public void testPayRent() { + Property property = new Property("TestProperty", 200, otherPlayerMock); + PayRent payRentEvent = new PayRent(50); + Player otherPlayerMock = mock(Player.class); + + when(gameMock.getCurrentPlayer()).thenReturn(playerMock); + + gameMock.receivedEvent(payRentEvent); + + verify(playerMock).payRent(50); + verify(otherPlayerMock).addMoney(50); + } + @Test + // T061: UC-gameplay-34 - Überprüfen, ob eine Warnung angezeigt wird, wenn der Spieler Schulden hat + public void testDebtWarning() { + when(playerMock.getBalance()).thenReturn(-100); + + gameMock.triggerDebtWarning(playerMock); + + verify(gameMock).sendMessage(new DebtWarning(playerMock)); + assertTrue("Der Spieler sollte in den Schuldenbereich geraten sein", playerMock.getBalance() < 0); + } + + @Test + // T062: UC-gameplay-35 - Überprüfen, ob der Spieler aufgrund einer Strafe eine Runde aussetzt + public void testSkipTurnDueToPenalty() { + PenaltyEvent penaltyEvent = new PenaltyEvent(1); // Spieler muss 1 Runde aussetzen + + when(playerHandlerMock.getPlayerState(playerMock)).thenReturn(PlayerState.ACTIVE); + + gameMock.receivedEvent(penaltyEvent); + + verify(playerHandlerMock).skipTurn(playerMock, 1); + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.WAIT_FOR_TURN); + assertEquals("Der Spieler sollte in den Zustand 'WaitForTurn' wechseln", PlayerState.WAIT_FOR_TURN, playerHandlerMock.getPlayerState(playerMock)); + } + + @Test + // T063: UC-gameplay-36 - Überprüfen, ob das Vermögen des Spielers korrekt angezeigt wird + public void testShowPlayerAssets() { + PlayerAssets playerAssets = new PlayerAssets(1000, 3); // Beispielvermögen und Grundstücke + when(playerMock.getAssets()).thenReturn(playerAssets); + + gameMock.sendPlayerAssets(playerMock); + + verify(gameMock).sendMessage(new PlayerAssetsResponse(playerAssets)); + } + + @Test + // T064: UC-gameplay-37 - Überprüfen, ob die Anzeige korrekt ist, wenn der Spieler keine "Gulag-Frei"-Karte hat + public void testNoGulagFreeCardDisplay() { + when(playerMock.getGulagFreeCards()).thenReturn(0); + + gameMock.updateGulagCardDisplay(playerMock); + + verify(gameMock).sendMessage(new GulagCardUpdate(playerMock, 0)); + } + + @Test + // T065: UC-gameplay-37 - Überprüfen, ob die Anzeige korrekt ist, wenn der Spieler eine "Gulag-Frei"-Karte hat + public void testOneGulagFreeCardDisplay() { + when(playerMock.getGulagFreeCards()).thenReturn(1); + + gameMock.updateGulagCardDisplay(playerMock); + + verify(gameMock).sendMessage(new GulagCardUpdate(playerMock, 1)); + } + + @Test + // T066: UC-gameplay-37 - Überprüfen, ob die Anzeige korrekt ist, wenn der Spieler zwei "Gulag-Frei"-Karten hat + public void testTwoGulagFreeCardsDisplay() { + when(playerMock.getGulagFreeCards()).thenReturn(2); + + gameMock.updateGulagCardDisplay(playerMock); + + verify(gameMock).sendMessage(new GulagCardUpdate(playerMock, 2)); + } + + @Test + // T067: UC-gameplay-38 - Überprüfen, ob die Anzahl der "Gulag-Frei"-Karten nach der Verwendung korrekt abgezogen wird + public void testTwoGulagFreeCardsDisplay() { + // Spieler hat zwei "Gulag-frei"-Karten und nutzt eine + GulagFreeCardUseEvent gulagFreeCardUseEvent = new GulagFreeCardUseEvent(playerMock); + + when(playerHandlerMock.getPlayerState(playerMock)).thenReturn(PlayerState.IN_JAIL); + when(playerHandlerMock.getGulagFreeCardCount(playerMock)).thenReturn(2); + + gameMock.receivedEvent(gulagFreeCardUseEvent); + + verify(playerHandlerMock).useGulagFreeCard(playerMock); + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.ACTIVE); + + assertEquals("Der Spieler sollte von 'InJail' auf 'Active' wechseln", PlayerState.ACTIVE, playerHandlerMock.getPlayerState(playerMock)); + } + + @Test + // T068: UC-gameplay-39 - Überprüfen, ob die Übersicht der anderen Spieler korrekt angezeigt wird + public void testViewOtherPlayers() { + PlayerOverview overview = new PlayerOverview("Player2", 1500, 5); + when(playerHandlerMock.getOtherPlayers(playerMock)).thenReturn(List.of(overview)); + + gameMock.sendPlayerOverview(playerMock); + + verify(gameMock).sendMessage(new PlayerOverviewResponse(List.of(overview))); + } + + @Test + // T069: UC-gameplay-44 - Überprüfen, ob der Spieler erfolgreich aus dem Gulag rauswürfeln kann + public void testRollToExitGulag() { + DiceResult diceResult = new DiceResult(4, 4); // Spieler würfelt Pasch + + when(playerHandlerMock.InJail(playerMock)).thenReturn(true); + gameMock.receivedEvent(diceResult); + + verify(playerHandlerMock).releasePlayerFromJail(playerMock); + verify(gameMock).sendMessage(new PlayerReleasedFromJail(playerMock)); + verify(playerHandlerMock).setPlayerState(playerMock, PlayerState.ACTIVE); + + assertEquals("Der Spieler sollte von 'InJail' auf 'Active' wechseln", PlayerState.ACTIVE, playerHandlerMock.getPlayerState(playerMock)); + } + + @Test + // T070: UC-gameplay-44 - Überprüfen, ob das Rauswürfeln aus dem Gulag fehlschlägt, wenn die Bedingungen nicht erfüllt sind + public void testFailRollToExitGulag() { + DiceResult diceResult = new DiceResult(2, 5); // Kein Pasch + + when(playerHandlerMock.InJail(playerMock)).thenReturn(true); + gameMock.receivedEvent(diceResult); + + verify(playerHandlerMock, never()).releasePlayerFromJail(playerMock); + verify(gameMock).sendMessage(new JailStayNotification(playerMock)); + } +} + } From 7a9e84f49cfa91ff1026289d145c8475f1edf544 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Sun, 17 Nov 2024 20:06:47 +0100 Subject: [PATCH 6/7] Tests bis T071 erweitert --- .../game/server/ServerGameLogicTest.java | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java index 2320086..935472f 100644 --- a/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java +++ b/Projekte/monopoly/model/src/test/java/pp/monopoly/game/server/ServerGameLogicTest.java @@ -564,5 +564,21 @@ public class ServerGameLogicTest { verify(playerHandlerMock, never()).releasePlayerFromJail(playerMock); verify(gameMock).sendMessage(new JailStayNotification(playerMock)); } -} + @Test +// T071: UC-gameplay-44 - Überprüfen, ob das Rauswürfeln aus dem Gulag fehlschlägt, wenn die Bedingungen nicht erfüllt sind + public void testFailRollToExitGulag() { + // Spieler versucht, sich aus dem Gulag herauszuwürfeln + RollDiceEvent rollDiceEvent = new RollDiceEvent(playerMock); + DiceResult diceResult = new DiceResult(3, 5); // Kein Pasch geworfen + + when(playerHandlerMock.getPlayerState(playerMock)).thenReturn(PlayerState.IN_JAIL); + when(gameMock.rollDice()).thenReturn(diceResult); + + gameMock.receivedEvent(rollDiceEvent); + + verify(playerHandlerMock, never()).setPlayerState(playerMock, PlayerState.ACTIVE); + verify(gameMock).notifyPlayer(playerMock, "Du bist weiterhin im Gulag. Versuche es erneut."); + assertEquals("Der Spieler sollte weiterhin im Zustand 'InJail' sein", PlayerState.IN_JAIL, playerHandlerMock.getPlayerState(playerMock)); } +} + From f1d52c445b6f8b05c8b335f96c733992596e20d8 Mon Sep 17 00:00:00 2001 From: Filip Szepielewicz Date: Fri, 22 Nov 2024 21:45:22 +0100 Subject: [PATCH 7/7] =?UTF-8?q?Tests=20bis=20T075=20=C3=BCberarbeitet?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../main/java/pp/battleship/client/Menu.java | 13 +- .../pp/battleship/exporter/ModelExporter.java | 7 +- .../Interface/Lemur/pp-styles.groovy | 82 +- Projekte/monopoly/client/build.gradle | 1 + .../java/pp/monopoly/client/GameSound.java | 39 +- .../main/java/pp/monopoly/client/Menu.java | 10 +- .../java/pp/monopoly/client/MonopolyApp.java | 486 ++----- .../pp/monopoly/client/MonopolyAppConfig.java | 10 +- .../pp/monopoly/client/MonopolyAppState.java | 40 +- .../pp/monopoly/client/NetworkDialog.java | 121 +- .../pp/monopoly/client/NetworkSupport.java | 64 +- .../java/pp/monopoly/client/StartMenu.java | 216 ++- .../client/gui/BoardSynchronizer.java | 51 +- .../java/pp/monopoly/client/gui/GameMenu.java | 1 + .../java/pp/monopoly/client/gui/MapView.java | 148 +- .../client/gui/MapViewSynchronizer.java | 62 +- .../main/resources/Pictures/logo-unibw.png | Bin 45063 -> 495563 bytes Projekte/monopoly/model/build.gradle | 7 +- .../main/java/pp/monopoly/MonopolyConfig.java | 9 +- .../monopoly/game/client/ClientGameLogic.java | 97 +- .../game/client/MonopolyClientConfig.java | 8 +- .../java/pp/monopoly/game/server/Player.java | 8 +- .../monopoly/game/server/PlayerHandler.java | 6 +- .../monopoly/game/server/ServerGameLogic.java | 33 + .../message/server/BuyPropertyResponse.java | 28 +- .../message/server/EventDrawCard.java | 9 + .../pp/monopoly/message/server/GameOver.java | 9 + .../pp/monopoly/message/server/JailEvent.java | 10 + .../message/server/PlayerStatusUpdate.java | 24 + .../message/server/ServerInterpreter.java | 7 - .../message/server/TimeOutWarning.java | 10 + .../message/server/UpdatePlayerAssets.java | 16 - .../message/server/ViewAssetsResponse.java | 6 +- .../main/java/pp/monopoly/model/Board.java | 14 +- .../main/java/pp/monopoly/model/Figure.java | 306 +++- .../main/java/pp/monopoly/model/IntPoint.java | 4 +- .../main/java/pp/monopoly/model/Visitor.java | 8 + .../java/pp/monopoly/model/VoidVisitor.java | 6 + .../java/pp/monopoly/model/card/Card.java | 2 +- .../monopoly/model/fields/BoardManager.java | 80 +- .../monopoly/notification/ItemAddedEvent.java | 48 +- .../notification/ItemRemovedEvent.java | 28 +- .../java/pp/monopoly/notification/Sound.java | 57 +- .../src/main/resources/monopoly.properties | 1 + .../test/java/pp/monopoly/Testhandbuch.java | 2 + .../pp/monopoly/client/ClientLogicTest.java | 88 +- .../game/client/ClientGameLogicTest.java | 597 +------- .../game/server/ServerGameLogicTest.java | 1229 +++++++++++------ .../pp/monopoly/server/MonopolyServer.java | 4 +- 49 files changed, 2161 insertions(+), 1951 deletions(-) delete mode 100644 Projekte/monopoly/model/src/main/java/pp/monopoly/message/server/UpdatePlayerAssets.java diff --git a/Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java b/Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java index 9143899..44a9a74 100644 --- a/Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java +++ b/Projekte/battleship/client/src/main/java/pp/battleship/client/Menu.java @@ -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 */ diff --git a/Projekte/battleship/converter/src/main/java/pp/battleship/exporter/ModelExporter.java b/Projekte/battleship/converter/src/main/java/pp/battleship/exporter/ModelExporter.java index ae9350b..5a95a98 100644 --- a/Projekte/battleship/converter/src/main/java/pp/battleship/exporter/ModelExporter.java +++ b/Projekte/battleship/converter/src/main/java/pp/battleship/exporter/ModelExporter.java @@ -45,7 +45,12 @@ public class ModelExporter extends SimpleApplication { export("Models/BoatSmall/12219_boat_v2_L2.obj", "BoatSmall.j3o"); //NON-NLS export("Models/Battle/14084_WWII_Ship_German_Type_II_U-boat_v2_L1.obj", "Battle.j3o"); //NON-NLS export("Models/CV/essex_scb-125_generic.obj", "CV.j3o"); //NON-NLS - + export("Models/Figures/Würfel_blau.obj", "Würfel_blau.j30"); + export("Models/Figures/Würfel_gelb.obj", "Würfel_gelb.j30"); + export("Models/Figures/Würfel_grün.obj", "Würfel_grün.j30"); + export("Models/Figures/Würfel_rosa.obj", "Würfel_rosa.j30"); + export("Models/Figures/Würfel_rot.obj", "Würfel_rot.j30"); + export("Models/Figures/Würfel_schwarz.obj", "Würfel_schwarz.j30"); stop(); } diff --git a/Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy b/Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy index 55ef6cb..68a0f6e 100644 --- a/Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy +++ b/Projekte/jme-common/src/main/resources/Interface/Lemur/pp-styles.groovy @@ -1,7 +1,8 @@ // Styling of Lemur components -// For documentation, see +// For documentation, see: // https://github.com/jMonkeyEngine-Contributions/Lemur/wiki/Styling - +import com.simsilica.lemur.* +import com.simsilica.lemur.component.QuadBackgroundComponent import com.simsilica.lemur.Button import com.simsilica.lemur.Button.ButtonAction import com.simsilica.lemur.Command @@ -11,19 +12,17 @@ import com.simsilica.lemur.component.QuadBackgroundComponent import com.simsilica.lemur.component.TbtQuadBackgroundComponent def bgColor = color(1, 1, 1, 1) -def buttonEnabledColor = color(0.8, 0.9, 1, 1) +def buttonEnabledColor = color(0, 0, 0, 1) def buttonDisabledColor = color(0.8, 0.9, 1, 0.2) -//def buttonBgColor = color(0, 0.75, 0.75, 1) +def buttonBgColor = color(1, 1, 1, 1) def sliderColor = color(0.6, 0.8, 0.8, 1) def sliderBgColor = color(0.5, 0.75, 0.75, 1) def gradientColor = color(0.5, 0.75, 0.85, 0.5) def tabbuttonEnabledColor = color(0.4, 0.45, 0.5, 1) +def solidWhiteBackground = new QuadBackgroundComponent(color(1, 1, 1, 1)) // Solid white +def greyBackground = color(0.8, 0.8, 0.8, 1) // Grey background color +def redBorderColor = color(1, 0, 0, 1) // Red border color -def playButtonBorderColor = color(1, 0.6, 0, 1) // Orange border for "Spielen" button -def playButtonTextColor = color(0, 0, 0, 1) // Black text color for "Spielen" button -def buttonBgColor = color(1, 1, 1, 1) // White background for "Spiel beenden" and "Einstellungen" buttons -def buttonTextColor = color(0, 0, 0, 1) // Black text color for "Spiel beenden" and "Einstellungen" buttons -def borderColor = color(0, 0, 0, 1) // Black border for "Spiel beenden" and "Einstellungen" def gradient = TbtQuadBackgroundComponent.create( @@ -34,7 +33,14 @@ def gradient = TbtQuadBackgroundComponent.create( def doubleGradient = new QuadBackgroundComponent(gradientColor) doubleGradient.texture = texture(name: "/com/simsilica/lemur/icons/double-gradient-128.png", - generateMips: false) + generateMips: false) + +def orangeBorder = TbtQuadBackgroundComponent.create( + texture(name: "/com/simsilica/lemur/icons/bordered-gradient.png", // Replace with an appropriate texture if needed + generateMips: false), + 1, 1, 1, 126, 126, + 1f, false) +orangeBorder.color = color(1, 0.5, 0, 1) // Orange color selector("pp") { font = font("Interface/Fonts/Metropolis/Metropolis-Regular-32.fnt") @@ -53,33 +59,31 @@ selector("header", "pp") { } selector("container", "pp") { - background = gradient.clone() + background = solidWhiteBackground.clone() 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) } -selector("play-button", "pp") { - color = playButtonTextColor // Black text color - background = new QuadBackgroundComponent(playButtonBorderColor) // Orange border background - insets = new Insets3f(15, 25, 15, 25) // Padding for larger button size - background.setMargin(5, 5) // Thin border effect around the background color - fontSize = 36 // Larger font size for prominence -} - -selector("menu-button", "pp") { - color = buttonTextColor // Black text color - background = new QuadBackgroundComponent(buttonBgColor) // White background - insets = new Insets3f(10, 20, 10, 20) // Padding - background.setMargin(1, 1) // Thin black border - background.setColor(borderColor) // Set black border color - - fontSize = 24 // Standard font size -} - def pressedCommand = new Command