Merge pull request #70 from rubenpirreram/Game-test-fix

Add: Game slot and draw tests

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

@@ -8,7 +8,6 @@ import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
-import java.io.IOException;
 import java.util.*;
 import java.util.concurrent.TimeUnit;
 
@@ -70,29 +69,44 @@ class GameTest {
         Player current = game.getCurrentState().getCurrentPlayer();
         assertNotNull(current);
 
-        if (game.getCurrentState().getNLower() > 0 && hasDrawableLower(game)) {
+        if (game.getCurrentState().getNLower() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
 
             if (index != -1) {
                 assertTrue(game.DrawLowerTribeCardByIndex(current, index));
-            } else {
+                return;
-                current.addFood(100);
-                assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
             }
 
-        } else if (game.getCurrentState().getNUpper() > 0 && hasDrawableUpper(game)) {
+            if (!game.getLowerListBuilding().isEmpty()) {
+                current.addFood(100);
+                assertTrue(game.DrawLowerBuildingCardByIndex(current, 0));
+                return;
+            }
+
+            assertTrue(game.SkipLowerDrawing(current));
+            return;
+        }
+
+        if (game.getCurrentState().getNUpper() > 0) {
             int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
 
             if (index != -1) {
                 assertTrue(game.DrawUpperTribeCardByIndex(current, index));
-            } else {
+                return;
-                current.addFood(100);
+            }
-                assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
+
+            if (!game.getUpperListBuilding().isEmpty()) {
+                current.addFood(100);
+                assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
+                return;
+            }
+
+            assertTrue(game.SkipUpperDrawing(current));
+            return;
         }
 
-        } else {
         fail(
-                    "Current player has no drawable cards, although the game is still resolving actions.\n" +
+                "Current player has no remaining draw actions.\n" +
                         "Current player: " + current + "\n" +
                         "Round: " + game.getCurrentState().getRound() + "\n" +
                         "Stage: " + game.getCurrentState().getGameStage() + "\n" +
@@ -109,7 +123,6 @@ class GameTest {
                         "First upper non-event: " + firstNonEventIndexOrMinusOne(game.getUpperListTribeCards())
         );
     }
-    }
 
     private void resolveActionsUntilOptionalCardEffect(Game game) {
         while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS) {
@@ -140,12 +153,13 @@ class GameTest {
         resolveOptionalPhaseIfPresent(game);
     }
 
-    private boolean hasDrawableLower(Game game) {
+    private void resolveCurrentPlayerCompletely(Game game, Player expectedPlayer) {
-        return firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1;
+        assertEquals(expectedPlayer, game.getCurrentState().getCurrentPlayer());
-    }
 
-    private boolean hasDrawableUpper(Game game) {
+        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS
-        return firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1;
+                && expectedPlayer.equals(game.getCurrentState().getCurrentPlayer())) {
+            resolveOneMandatoryAction(game);
+        }
     }
 
     @Test
@@ -806,7 +820,7 @@ class GameTest {
         assertFalse(game.PickOptionalBuildingCard(current, 0));
     }
     @Test
-    void toStringModel() throws IOException, InterruptedException {
+    void toStringModel() {
         Game game=new Game(5);
         Player p1=new Player("p1");
         Player p2=new Player("p2");
@@ -826,6 +840,119 @@ class GameTest {
             assertTrue(game.SlotChoiceByIndex(game.getCurrentState().getCurrentPlayer(), i));
         }
 
-        System.out.println(game.toString());
+        String result = game.toString();
+
+        assertNotNull(result);
+        assertFalse(result.isBlank());
+        assertTrue(result.contains("CURRENT STATE"));
+    }
+
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS)
+    void shouldDrawLowerBuildingWhenAvailableAndPlayerCanPay() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "lower_building_");
+
+        for (int safety = 0; safety < 300; safety++) {
+
+            if (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
+                completeSlotChoice(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS) {
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                if (game.getCurrentState().getNLower() > 0
+                        && !game.getLowerListBuilding().isEmpty()) {
+
+                    current.addFood(100);
+
+                    int buildingsBefore = current.buildingCards.size();
+                    int lowerBuildingsBefore = game.getLowerListBuilding().size();
+                    int foodBefore = current.getFoodValue();
+
+                    assertTrue(
+                            game.DrawLowerBuildingCardByIndex(current, 0),
+                            "DrawLowerBuildingCardByIndex should return true when lower building exists, player can draw lower, and player has food."
+                    );
+
+                    assertEquals(buildingsBefore + 1, current.buildingCards.size());
+                    assertEquals(lowerBuildingsBefore - 1, game.getLowerListBuilding().size());
+                    assertTrue(current.getFoodValue() < foodBefore);
+
+                    return;
+                }
+
+                resolveOneMandatoryAction(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.OPTIONAL_CARD_EFFECT) {
+                resolveOptionalPhaseIfPresent(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.ENDED) {
+                break;
+            }
+        }
+
+        fail("The test never reached a state with NLower > 0 and at least one lower building.");
+    }
+
+    @Test
+    void drawBuildingShouldReturnFalseIfPlayerCannotPay() {
+        Game game = new Game(3);
+        addPlayers(game, 3, "no_food_building_");
+
+        completeSlotChoice(game);
+
+        while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS) {
+            Player current = game.getCurrentState().getCurrentPlayer();
+
+            if (game.getCurrentState().getNUpper() > 0
+                    && !game.getUpperListBuilding().isEmpty()
+                    && current.builders.isEmpty()) {
+
+                while (current.getFoodValue() > 0) {
+                    assertTrue(current.removeFood(1));
+                }
+
+                assertEquals(0, current.getFoodValue());
+                assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
+                return;
+            }
+
+            resolveOneMandatoryAction(game);
+        }
+
+        fail("No upper building draw state reached with a player without builders.");
+    }
+
+    @Test
+    void shouldResolvePlayersAccordingToSlotOrder() {
+        Game game = new Game(3);
+        addPlayers(game, 3, "slot_order_");
+
+        Player firstChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(firstChooser, 2));
+
+        Player secondChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(secondChooser, 0));
+
+        Player thirdChooser = game.getCurrentState().getCurrentPlayer();
+        assertTrue(game.SlotChoiceByIndex(thirdChooser, 1));
+
+        assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
+
+        assertEquals(secondChooser, game.getCurrentState().getCurrentPlayer());
+
+        resolveCurrentPlayerCompletely(game, secondChooser);
+
+        assertEquals(thirdChooser, game.getCurrentState().getCurrentPlayer());
+
+        resolveCurrentPlayerCompletely(game, thirdChooser);
+
+        assertEquals(firstChooser, game.getCurrentState().getCurrentPlayer());
     }
 }