Add: final scoring and Game flow coverage tests

src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java

@@ -4,15 +4,12 @@ import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCard;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Character;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.CharacterType;
-import it.polimi.ingsw.gc14.Model.GamePackage.Board;
 import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
-import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Artist;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Builder;
 import it.polimi.ingsw.gc14.Model.Cards.TribeCards.Characters.Inventor;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
-import java.lang.reflect.Field;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
@@ -28,8 +25,15 @@ class GameTest {
         for (int i = 0; i < game.getNPlayers(); i++) {
             Player current = game.getCurrentState().getCurrentPlayer();
             order.add(current);
+
             assertTrue(game.SlotChoiceByIndex(current, i));
-            assertEquals(current.getUserName(),game.getSlotMap().get(new ArrayList<>(game.getSlotMap().keySet()).get(i)).getUserName());
+
+            assertTrue(
+                    game.getSlotMap().values().stream()
+                            .anyMatch(player -> player != null
+                                    && player.getUserName().equals(current.getUserName())),
+                    "The selected player should be present in the slot map."
+            );
         }
 
         assertEquals(GameStages.RES_ACTIONS, game.getCurrentState().getGameStage());
@@ -1057,121 +1061,25 @@ class GameTest {
         assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
     }
 
-    @Test
+    private void preparePlayerForComparableFinalScoring(Player player) {
-    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+        player.buildingCards.clear();
-    void endGameShouldAddBuildingPrestigeValues() {
-        Game game = new Game(3);
 
-        List<Player> players = addPlayers(game, 3, "building_prestige_");
+        player.builders.clear();
+        player.inventors.clear();
+        player.artists.clear();
+        player.hunters.clear();
+        player.shamans.clear();
+        player.gatherers.clear();
 
-        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+        while (player.getFoodValue() > 0) {
-
+            assertTrue(player.removeFood(1));
-        while (game.getCurrentState().getRound() < 10) {
-            playOneFullRound(game);
         }
 
-        completeSlotChoice(game);
+        /*
-        resolveAllMandatoryActions(game);
+         * Mantiene l'effetto opzionale, ma con prestigio finale nullo.
-
+         * Così la fase OPT_CARD_E rimane coerente e il confronto resta controllato.
-        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+         */
-
+        player.buildingCards.add(new BuildingCard(12, 1, 1, 0));
-        Player player = players.get(0);
-
-        try {
-            Field boardField = Game.class.getDeclaredField("board");
-            boardField.setAccessible(true);
-            Board board = (Board) boardField.get(game);
-
-            Field upperTribe = Board.class.getDeclaredField("upperListTribe");
-            upperTribe.setAccessible(true);
-            List<TribeCard> upper = (List<TribeCard>) upperTribe.get(board);
-            upper.removeIf(TribeCard::IsEventCard);
-
-            Field lowerTribe = Board.class.getDeclaredField("lowerListTribe");
-            lowerTribe.setAccessible(true);
-            List<TribeCard> lower = (List<TribeCard>) lowerTribe.get(board);
-            lower.removeIf(TribeCard::IsEventCard);
-
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            fail("Reflection fallita: " + e.getMessage());
-        }
-
-        int prestigeBefore = player.getPrestigeValue();
-
-        player.buildingCards.add(new BuildingCard(12, 1, 1, 7));
-        player.buildingCards.add(new BuildingCard(12, 1, 1, 5));
-
-        int expectedMinimumIncrease = 7 + 5;
-
-        resolveOptionalPhaseIfPresent(game);
-
-        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
-
-        assertTrue(
-                player.getPrestigeValue() >= prestigeBefore + expectedMinimumIncrease,
-                "Final scoring should add at least the prestige values of the two added building cards."
-        );
-    }
-
-    @Test
-    @Timeout(value = 20, unit = TimeUnit.SECONDS)
-    void endGameShouldApplyFinalCharacterPrestigeBonuses() {
-        Game game = new Game(3);
-
-        List<Player> players = addPlayers(game, 3, "final_characters_");
-        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
-
-        while (game.getCurrentState().getRound() < 10) {
-            playOneFullRound(game);
-        }
-
-        completeSlotChoice(game);
-        resolveAllMandatoryActions(game);
-
-        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
-
-        Player player = players.get(0);
-        assertNotNull(player);
-
-        try {
-            Field boardField = Game.class.getDeclaredField("board");
-            boardField.setAccessible(true);
-            Board board = (Board) boardField.get(game);
-
-            Field upperTribe = Board.class.getDeclaredField("upperListTribe");
-            upperTribe.setAccessible(true);
-            List<TribeCard> upper = (List<TribeCard>) upperTribe.get(board);
-            upper.removeIf(TribeCard::IsEventCard);
-
-            Field lowerTribe = Board.class.getDeclaredField("lowerListTribe");
-            lowerTribe.setAccessible(true);
-            List<TribeCard> lower = (List<TribeCard>) lowerTribe.get(board);
-            lower.removeIf(TribeCard::IsEventCard);
-
-        } catch (NoSuchFieldException | IllegalAccessException e) {
-            fail("Reflection fallita: " + e.getMessage());
-        }
-
-        int prestigeBefore = player.getPrestigeValue();
-
-        player.builders.add(new Builder(1, 0, 4));
-
-        player.inventors.add(new Inventor(1, 0));
-        player.inventors.add(new Inventor(1, 1));
-
-        player.artists.add(new Artist(1));
-        player.artists.add(new Artist(1));
-
-        int expectedMinimumIncrease = 4 + 4 + 10;
-
-        resolveOptionalPhaseIfPresent(game);
-
-        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
-
-        assertTrue(
-                player.getPrestigeValue() >= prestigeBefore + expectedMinimumIncrease,
-                "Final scoring should add at least builder prestige, inventor bonus, and artist pair bonus."
-        );
     }
 
     @Test
@@ -1202,46 +1110,63 @@ class GameTest {
         Player current = game.getCurrentState().getCurrentPlayer();
         assertNotNull(current);
 
-        boolean checkedAtLeastOneSkip = false;
+        boolean hasDrawableLowerTribe =
+                game.getCurrentState().getNLower() > 0
+                        && firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1;
 
-        if (game.getCurrentState().getNLower() > 0 || game.getLowerListTribeCards().stream().allMatch(TribeCard::IsEventCard)) {
+        boolean hasDrawableUpperTribe =
-            assertFalse(game.SkipNoDrawable(current));
+                game.getCurrentState().getNUpper() > 0
-            checkedAtLeastOneSkip = true;
+                        && firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1;
-        }
-
-        if (game.getCurrentState().getNUpper() > 0|| game.getUpperListTribeCards().stream().allMatch(TribeCard::IsEventCard)) {
-            assertFalse(game.SkipNoDrawable(current));
-            checkedAtLeastOneSkip = true;
-        }
 
         assertTrue(
-                checkedAtLeastOneSkip,
+                hasDrawableLowerTribe || hasDrawableUpperTribe,
-                "The test should check at least one skip rejection when drawable cards exist."
+                "The test requires at least one drawable tribe card."
         );
+
+        assertFalse(game.SkipNoDrawable(current));
     }
 
     @Test
-    void pickOptionalTribeCardShouldRejectEventCard() {
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void pickOptionalTribeCardShouldRejectEventCardIfPresent() {
         Game game = new Game(3);
 
         List<Player> players = addPlayers(game, 3, "optional_event_");
 
         giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
 
-        completeSlotChoice(game);
+        while (game.getCurrentState().getGameStage() != GameStages.ENDED) {
-        resolveActionsUntilOptionalCardEffect(game);
+            assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
 
-        Player current = game.getCurrentState().getCurrentPlayer();
+            completeSlotChoice(game);
-        assertNotNull(current);
+            resolveActionsUntilOptionalCardEffect(game);
 
-        int eventIndex = firstEventIndexOrMinusOne(game.getUpperListTribeCards());
+            Player current = game.getCurrentState().getCurrentPlayer();
+            assertNotNull(current);
 
-        if(eventIndex==-1)
+            int eventIndex = firstEventIndexOrMinusOne(game.getUpperListTribeCards());
-        {
+
-            assertFalse(game.NoOptionalCard(current));
+            if (eventIndex != -1) {
+                int charactersBefore = current.getTotCharacters();
+                int upperSizeBefore = game.getUpperListTribeCards().size();
+
+                assertFalse(game.PickOptionalTribeCardByIndex(current, eventIndex));
+
+                assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+                assertEquals(current, game.getCurrentState().getCurrentPlayer());
+                assertEquals(charactersBefore, current.getTotCharacters());
+                assertEquals(upperSizeBefore, game.getUpperListTribeCards().size());
+
+                return;
+            }
+
+            resolveOptionalPhaseIfPresent(game);
         }
 
-        assertFalse(game.PickOptionalTribeCardByIndex(current, eventIndex));
+        org.junit.jupiter.api.Assumptions.assumeTrue(
+                false,
+                "No optional phase with an event card in the upper tribe list was reached."
+        );
     }
 
     @Test
@@ -1492,4 +1417,210 @@ class GameTest {
 
         assertEquals(foodBefore, current.getFoodValue());
     }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldAddExactBuildingPrestigeValues() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "final_building_scoring_");
+
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        assertEquals(10, game.getCurrentState().getRound());
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        Player controlPlayer = players.get(0);
+        Player testedPlayer = players.get(1);
+
+        assertNotNull(controlPlayer);
+        assertNotNull(testedPlayer);
+
+        /*
+         * I due player vengono resi identici rispetto a Eventi e final scoring.
+         * La partita è comunque arrivata realmente al round 10.
+         */
+        preparePlayerForComparableFinalScoring(controlPlayer);
+        preparePlayerForComparableFinalScoring(testedPlayer);
+        preparePlayerForComparableFinalScoring(players.get(2));
+
+        BuildingCard firstBuilding = new BuildingCard(12, 1, 1, 7);
+        BuildingCard secondBuilding = new BuildingCard(12, 1, 1, 5);
+
+        testedPlayer.buildingCards.add(firstBuilding);
+        testedPlayer.buildingCards.add(secondBuilding);
+
+        int prestigeDifferenceBefore =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        int expectedExtraIncrease =
+                firstBuilding.getPrestigeValue()
+                        + secondBuilding.getPrestigeValue();
+
+        resolveOptionalPhaseIfPresent(game);
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+
+        int prestigeDifferenceAfter =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        assertEquals(
+                expectedExtraIncrease,
+                prestigeDifferenceAfter - prestigeDifferenceBefore,
+                "Final scoring should add exactly the printed prestige values of the added buildings."
+        );
+    }
+
+    @Test
+    void playersStampShouldReturnPlayersInformation() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "stamp_");
+
+        String result = game.PlayersStamp();
+
+        assertNotNull(result);
+        assertFalse(result.isBlank());
+        assertTrue(result.contains("stamp_1"));
+        assertTrue(result.contains("stamp_2"));
+        assertTrue(result.contains("stamp_3"));
+    }
+
+    @Test
+    void boardStampShouldReturnBoardInformation() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "board_stamp_");
+
+        String result = game.BoardStamp();
+
+        assertNotNull(result);
+        assertFalse(result.isBlank());
+        assertTrue(result.contains("CURRENT STATE"));
+        assertTrue(result.contains("Char/Events"));
+        assertTrue(result.contains("Building"));
+    }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldAddExactBuilderPrestigeValues() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "final_builder_scoring_");
+
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        assertEquals(10, game.getCurrentState().getRound());
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        Player controlPlayer = players.get(0);
+        Player testedPlayer = players.get(1);
+
+        assertNotNull(controlPlayer);
+        assertNotNull(testedPlayer);
+
+        preparePlayerForComparableFinalScoring(controlPlayer);
+        preparePlayerForComparableFinalScoring(testedPlayer);
+        preparePlayerForComparableFinalScoring(players.get(2));
+
+        controlPlayer.builders.add(new Builder(1, 0, 0));
+        controlPlayer.builders.add(new Builder(1, 0, 0));
+
+        testedPlayer.builders.add(new Builder(1, 0, 4));
+        testedPlayer.builders.add(new Builder(1, 0, 3));
+
+        int prestigeDifferenceBefore =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        int expectedExtraIncrease = 4 + 3;
+
+        resolveOptionalPhaseIfPresent(game);
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+
+        int prestigeDifferenceAfter =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        assertEquals(
+                expectedExtraIncrease,
+                prestigeDifferenceAfter - prestigeDifferenceBefore,
+                "Final scoring should add exactly the prestige values of the builders."
+        );
+    }
+
+    @Test
+    @Timeout(value = 20, unit = TimeUnit.SECONDS)
+    void endGameShouldAddExactInventorPrestigeValues() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "final_inventor_scoring_");
+
+        giveOptionalEffectToAllPlayers(players.get(0), players.get(1), players.get(2));
+
+        while (game.getCurrentState().getRound() < 10) {
+            playOneFullRound(game);
+        }
+
+        assertEquals(10, game.getCurrentState().getRound());
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        completeSlotChoice(game);
+        resolveAllMandatoryActions(game);
+
+        assertEquals(GameStages.OPT_CARD_E, game.getCurrentState().getGameStage());
+
+        Player controlPlayer = players.get(0);
+        Player testedPlayer = players.get(1);
+
+        assertNotNull(controlPlayer);
+        assertNotNull(testedPlayer);
+
+        preparePlayerForComparableFinalScoring(controlPlayer);
+        preparePlayerForComparableFinalScoring(testedPlayer);
+        preparePlayerForComparableFinalScoring(players.get(2));
+
+        controlPlayer.builders.add(new Builder(1, 0, 0));
+        controlPlayer.builders.add(new Builder(1, 0, 0));
+        controlPlayer.builders.add(new Builder(1, 0, 0));
+
+        testedPlayer.inventors.add(new Inventor(1, 0));
+        testedPlayer.inventors.add(new Inventor(1, 1));
+        testedPlayer.inventors.add(new Inventor(1, 1));
+
+        int prestigeDifferenceBefore =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        int expectedExtraIncrease = 3 * 2;
+
+        resolveOptionalPhaseIfPresent(game);
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+
+        int prestigeDifferenceAfter =
+                testedPlayer.getPrestigeValue() - controlPlayer.getPrestigeValue();
+
+        assertEquals(
+                expectedExtraIncrease,
+                prestigeDifferenceAfter - prestigeDifferenceBefore,
+                "Final scoring should add exactly inventors times different invention icons."
+        );
+    }
 }