Fix: GameTest

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

@@ -1,5 +1,6 @@
 package it.polimi.ingsw.gc14.Model;
 
+import it.polimi.ingsw.gc14.Model.Cards.Building.EffectType;
 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;
@@ -13,10 +14,11 @@ import static org.junit.jupiter.api.Assertions.*;
 
 class GameTest {
 
+
     private Queue<Player> completeSlotChoice(Game game) {
         Queue<Player> order = new LinkedList<>();
 
-        for (int i = 0; i < 3; i++) {
+        for (int i = 0; i < game.getNPlayers(); i++) {
             Player current = game.getCurrentState().getCurrentPlayer();
             order.add(current);
 
@@ -49,61 +51,68 @@ class GameTest {
         return -1;
     }
 
-    private void giveOptionalEffectToAllPlayers(Player p1, Player p2, Player p3) {
+    private void giveOptionalEffectToAllPlayers(Player... players) {
-        p1.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+        for (Player player : players) {
-        p2.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+            player.buildingCards.add(new BuildingCard(12, 1, 1, 0));
-        p3.buildingCards.add(new BuildingCard(12, 1, 1, 0));
+        }
     }
 
-    private void resolveActionsUntilOptionalCardEffect(Game game) {
+    private void resolveAllMandatoryActions(Game game) {
         int guard = 0;
 
-        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 20) {
+        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 50) {
             guard++;
+            resolveOneMandatoryAction(game);
+        }
 
+        assertTrue(guard < 50, "Possible infinite loop while resolving mandatory actions.");
+    }
+
+    private void resolveOneMandatoryAction(Game game) {
         Player current = game.getCurrentState().getCurrentPlayer();
         assertNotNull(current);
 
         if (game.getCurrentState().getNLower() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
 
-                if (index == -1) {
+            if (index != -1) {
-                    fail("No lower non-event tribe card available.");
+                assertTrue(game.DrawLowerTribeCardByIndex(current, index));
+            } else if (!game.getLowerListBuilding().isEmpty()) {
+                current.addFood(100);
+                assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
+            } else {
+                fail("No valid lower card available.");
             }
 
-                assertTrue(game.DrawLowerTribeCardByIndex(current, index));
         } else if (game.getCurrentState().getNUpper() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
 
             if (index != -1) {
                 assertTrue(game.DrawUpperTribeCardByIndex(current, index));
-                } else {
+            } else if (!game.getUpperListBuilding().isEmpty()) {
                 current.addFood(100);
                 assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
+            } else {
+                fail("No valid upper card available.");
             }
+
         } else {
             fail("Current player has no remaining draws.");
         }
     }
 
+    private void resolveActionsUntilOptionalCardEffect(Game game) {
+        int guard = 0;
+
+        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 50) {
+            guard++;
+            resolveOneMandatoryAction(game);
+        }
+
+        assertTrue(guard < 50, "Possible infinite loop while resolving mandatory actions.");
         assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
     }
 
-    private static class FinalTestBuildingCard extends BuildingCard {
-        FinalTestBuildingCard() {
-            super(12, 1, 1, 0);
-        }
-
-        @Override
-        public it.polimi.ingsw.gc14.Model.Cards.Building.EffectType getEffectType() {
-            return it.polimi.ingsw.gc14.Model.Cards.Building.EffectType.FINAL;
-        }
-
-        @Override
-        public void applyEffect(Player player) {
-            player.addPrestige(10);
-        }
-    }
 
     private void setCurrentStateEra(Game game, int era) {
         try {
@@ -115,19 +124,42 @@ class GameTest {
         }
     }
 
-    @Test void Game()
+    private static class FinalTestBuildingCard extends BuildingCard {
-    {
+
+        FinalTestBuildingCard() {
+            super(12, 1, 1, 0);
+        }
+
+        @Override
+        public EffectType getEffectType() {
+            return EffectType.FINAL;
+        }
+
+        @Override
+        public void applyEffect(Player player) {
+            player.addPrestige(10);
+        }
+    }
+
+    @Test
+    void constructorShouldInitializeGameCorrectly() {
         int nPlayers = 3;
         Game game = new Game(nPlayers);
+
         assertEquals(nPlayers, game.getNPlayers());
         assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
 
         assertThrows(IllegalArgumentException.class, () -> new Game(6));
         assertThrows(IllegalArgumentException.class, () -> new Game(-1));
+
         game = new Game();
+
         assertFalse(game.addPlayer(new Player("p1")));
-        game.setNPlayer(nPlayers);
+
+
+        assertTrue(game.setNPlayer(nPlayers));
         assertTrue(game.addPlayer(new Player("p1")));
+
         assertEquals(nPlayers, game.getNPlayers());
         assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
     }
@@ -138,6 +170,7 @@ class GameTest {
         Game game = new Game(nPlayers);
         assertEquals(nPlayers + 4, game.getUpperListTribeCards().size());
     }
+
     @Test
     void getUpperListBuildingCards() {
         int nPlayers = 3;
@@ -184,7 +217,7 @@ class GameTest {
     }
 
     @Test
-    void addPlayer() {
+    void addPlayerShouldRejectDuplicatesAndStartSlotChoiceWhenFull() {
         Game game = new Game(3);
         Player p1 = new Player("p1");
         Player p2 = new Player("p2");
@@ -252,7 +285,7 @@ class GameTest {
         int index;
         List<TribeCard> cards = game.getLowerListTribeCards();
 
-        index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+        index = firstNonEventIndex(cards);
         assertTrue(game.DrawLowerTribeCardByIndex(temp_player, index));
 
         temp_player = players.poll();
@@ -263,11 +296,16 @@ class GameTest {
         Arrays.stream(CharacterType.values()).forEach(type -> nCardsByType.put(type, 0));
         while (game.getCurrentState().getNUpper() > 1) {
             cards = game.getUpperListTribeCards();
-            TribeCard temp_card=cards.stream().filter(x->!x.IsEventCard()).findFirst().get();
+            index = firstNonEventIndexOrMinusOne(cards);
-            index=cards.indexOf(temp_card);
+
-            assertEquals(nCards-countCards,game.getUpperListTribeCards().size()-countCards);
+            if (index == -1) {
-            drawTribeTest(nCardsByType,nCards,countCards,temp_card,temp_player,game);
+                break;
+            }
+
+            TribeCard temp_card = cards.get(index);
+            assertEquals(nCards - countCards, game.getUpperListTribeCards().size());
             assertTrue(game.DrawUpperTribeCardByIndex(temp_player, index));
+            drawTribeTest(nCardsByType, temp_card, temp_player);
             countCards++;
         }
         cards = game.getUpperListTribeCards();
@@ -276,40 +314,48 @@ class GameTest {
         if (eventIndex != -1) {
             assertFalse(game.DrawUpperTribeCardByIndex(temp_player, eventIndex));
         }
-        //index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+
-        //assertTrue(game.DrawUpperTribeCardByIndex(temp_player,index));
         temp_player.addFood(100);
+
+        assertFalse(game.getUpperListBuilding().isEmpty());
+
         index = 0;
         assertTrue(game.DrawUpperBuildingCardByIndex(temp_player, index));
-        index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
+
-        assertFalse(game.DrawUpperTribeCardByIndex(temp_player,index));
+        int remainingTribeIndex = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
+        if (remainingTribeIndex != -1) {
+            assertFalse(game.DrawUpperTribeCardByIndex(temp_player, remainingTribeIndex));
+        }
 
 
     }
-    private void drawTribeTest(HashMap<CharacterType,Integer>nCardsByType,int nCards,int countCards,TribeCard temp_card,Player temp_player,Game game) {
+
+    private void drawTribeTest(HashMap<CharacterType, Integer> nCardsByType,
+                               TribeCard temp_card,
+                               Player temp_player) {
 
         switch (((Character) temp_card).getType()) {
-            case CharacterType.ARTIST:
+            case ARTIST:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.artists.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
-            case CharacterType.INVENTOR:
+            case INVENTOR:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.inventors.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
-            case CharacterType.HUNTER:
+            case HUNTER:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.hunters.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
-            case CharacterType.SHAMAN:
+            case SHAMAN:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.shamans.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
-            case CharacterType.BUILDER:
+            case BUILDER:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.builders.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
-            case CharacterType.GATHERER:
+            case GATHERER:
                 assertEquals(nCardsByType.get(((Character) temp_card).getType()) + 1, temp_player.gatherers.size());
                 nCardsByType.merge(((Character) temp_card).getType(), 1, Integer::sum);
                 break;
@@ -533,24 +579,6 @@ class GameTest {
         }
     }
 
-    @Test
-    void drawUpperTribeCardShouldReturnFalseForEventCardIfPresent() {
-        Game game = new Game(3);
-
-        addPlayers(game, 3, "event_");
-
-        completeSlotChoice(game);
-
-        Player current = game.getCurrentState().getCurrentPlayer();
-        assertNotNull(current);
-
-        int eventIndex = firstEventIndexOrMinusOne(game.getUpperListTribeCards());
-
-        if (eventIndex != -1) {
-            assertFalse(game.DrawUpperTribeCardByIndex(current, eventIndex));
-        }
-    }
-
     @Test
     void drawLowerBuildingCardShouldWorkWhenLowerBuildingExists() {
         Game game = new Game(3);
@@ -596,7 +624,7 @@ class GameTest {
     }
 
     @Test
-    void optionalMethodsShouldRejectWrongPlayerInvalidIndexesAndEventCards() {
+    void optionalMethodsShouldRejectWrongPlayerAndInvalidIndexes() {
         Game game = new Game(3);
 
         List<Player> players = addPlayers(game, 3, "optional_invalid_");
@@ -621,11 +649,6 @@ class GameTest {
         assertFalse(game.PickOptionalBuildingCard(current, -1));
         assertFalse(game.PickOptionalBuildingCard(current, 999));
 
-        int eventIndex = firstEventIndexOrMinusOne(game.getUpperListTribeCards());
-
-        if (eventIndex != -1) {
-            assertFalse(game.PickOptionalTribeCardByIndex(current, eventIndex));
-        }
     }
 
     @Test
@@ -670,22 +693,6 @@ class GameTest {
         assertEquals(roundBefore + 1, game.getCurrentState().getRound());
     }
 
-    @Test
-    void nextRoundAtRoundTenShouldEndGame() {
-        Game game = new Game(3);
-
-        for (int i = 0; i < 9; i++) {
-            game.getCurrentState().RoundUpdate();
-        }
-
-        assertEquals(10, game.getCurrentState().getRound());
-
-        invokePrivateMethod(game, "nextRound");
-
-        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
-    }
-
-
     @Test
     void addObserverAndNotifyObserversShouldCallObserver() {
         Game game = new Game(3);
@@ -797,7 +804,7 @@ class GameTest {
     }
 
     @Test
-    void eventResolutionShouldActivateNormalAndSustenanceEvents() {
+    void eventResolutionShouldNotCrashWithNormalAndSustenanceEvents() {
         Game game = new Game(3);
 
         addPlayers(game, 3, "events_");
@@ -838,7 +845,12 @@ class GameTest {
         Game game = new Game(3);
 
         Player player = new Player("final_player");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
         assertTrue(game.addPlayer(player));
+        assertTrue(game.addPlayer(p2));
+        assertTrue(game.addPlayer(p3));
 
         player.buildingCards.add(new FinalTestBuildingCard());
 
@@ -850,4 +862,126 @@ class GameTest {
         assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
     }
 
+    @Test
+    void shouldNotCrashWhenNoPlayerHasOptionalEffect() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "no_optional_");
+
+        completeSlotChoice(game);
+
+        assertDoesNotThrow(() -> resolveAllMandatoryActions(game));
+
+        assertNotEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+    }
+
+
+    @Test
+    void constructorShouldRejectOnePlayerGame() {
+        assertThrows(IllegalArgumentException.class, () -> new Game(1));
+    }
+
+    @Test
+    void setNPlayerShouldAllowCompleteGameSetup() {
+        Game game = new Game();
+
+        assertTrue(game.setNPlayer(3));
+
+        assertTrue(game.addPlayer(new Player("p1")));
+        assertTrue(game.addPlayer(new Player("p2")));
+        assertTrue(game.addPlayer(new Player("p3")));
+
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        assertTrue(game.SlotChoiceByIndex(current, 0));
+    }
+
+    @Test
+    void nextRoundAtRoundTenShouldNotIncreaseRoundAfterEndingGame() {
+        Game game = new Game(3);
+
+        for (int i = 0; i < 9; i++) {
+            game.getCurrentState().RoundUpdate();
+        }
+
+        assertEquals(10, game.getCurrentState().getRound());
+
+        invokePrivateMethod(game, "nextRound");
+
+        assertEquals(GameStages.ENDED, game.getCurrentState().getGameStage());
+        assertEquals(10, game.getCurrentState().getRound());
+    }
+
+    @Test
+    void setNPlayerShouldRejectInvalidPlayerCounts() {
+        assertFalse(new Game().setNPlayer(-1));
+        assertFalse(new Game().setNPlayer(1));
+        assertFalse(new Game().setNPlayer(6));
+    }
+
+    @Test
+    void addPlayerShouldRejectDifferentPlayerWithSameUsername() {
+        Game game = new Game(3);
+
+        assertTrue(game.addPlayer(new Player("same_name")));
+        assertFalse(game.addPlayer(new Player("same_name")));
+    }
+
+    @Test
+    void shouldNotCrashWhenOnlyOptionalPlayerSkipsOptionalCard() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "single_optional_");
+
+        players.get(0).buildingCards.add(new BuildingCard(12, 1, 1, 0));
+
+        completeSlotChoice(game);
+        resolveActionsUntilOptionalCardEffect(game);
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        assertDoesNotThrow(() -> assertTrue(game.NoOptionalCard(current)));
+
+        assertNotEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+    }
+
+    @Test
+    void optionalPhaseShouldFinishAfterAllPlayersSkipOptionalCard() {
+        Game game = new Game(3);
+
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+
+        assertTrue(game.addPlayer(p1));
+        assertTrue(game.addPlayer(p2));
+        assertTrue(game.addPlayer(p3));
+
+        giveOptionalEffectToAllPlayers(p1, p2, p3);
+
+        completeSlotChoice(game);
+        resolveActionsUntilOptionalCardEffect(game);
+
+        assertDoesNotThrow(() -> {
+            int guard = 0;
+
+            while (game.getCurrentState().getGameStage() == GameStages.OPTIONAL_CARD_EFFECT && guard < 10) {
+                guard++;
+
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                assertTrue(game.NoOptionalCard(current));
+            }
+
+            assertTrue(guard < 10, "Possible infinite loop during optional phase.");
+            assertNotEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
+        });
+    }
+
+
 }