diff --git a/src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java b/src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java
index 1f5bb4e..327c10a 100644
--- a/src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java
+++ b/src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java
@@ -934,34 +934,65 @@ class GameTest {
     }
 
     @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS)
     void drawBuildingShouldReturnFalseIfPlayerCannotPay() {
         Game game = new Game(3);
-        addPlayers(game, 3, "no_food_building_");
 
-        completeSlotChoice(game);
+        addPlayers(game, 3, "no_food_upper_building_");
 
-        while (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
-            Player current = game.getCurrentState().getCurrentPlayer();
+        for (int safety = 0; safety < 300; safety++) {
 
-            if (game.getCurrentState().getNUpper() > 0
-                    && !game.getUpperListBuilding().isEmpty()) {
-
-                while (current.getFoodValue() > 0) {
-                    assertTrue(current.removeFood(1));
-                }
-
-                current.builders.clear();
-
-                assertEquals(0, current.getFoodValue());
-
-                assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
-                return;
+            if (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
+                completeSlotChoice(game);
             }
 
-            resolveOneMandatoryAction(game);
+            if (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                if (game.getCurrentState().getNUpper() > 0
+                        && !game.getUpperListBuilding().isEmpty()) {
+
+                    BuildingCard selectedBuilding = game.getUpperListBuilding().get(0);
+
+                    if (selectedBuilding.getPrice() <= 0) {
+                        resolveOneMandatoryAction(game);
+                        continue;
+                    }
+
+                    while (current.getFoodValue() > 0) {
+                        assertTrue(current.removeFood(1));
+                    }
+
+                    current.builders.clear();
+
+                    assertEquals(0, current.getFoodValue());
+
+                    int buildingsBefore = current.buildingCards.size();
+                    int upperBuildingsBefore = game.getUpperListBuilding().size();
+
+                    assertFalse(game.DrawUpperBuildingCardByIndex(current, 0));
+
+                    assertEquals(buildingsBefore, current.buildingCards.size());
+                    assertEquals(upperBuildingsBefore, game.getUpperListBuilding().size());
+                    assertEquals(0, current.getFoodValue());
+
+                    return;
+                }
+
+                resolveOneMandatoryAction(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
+                resolveOptionalPhaseIfPresent(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.ENDED) {
+                break;
+            }
         }
 
-        fail("No upper building draw state reached.");
+        fail("The test never reached a state with NUpper > 0 and at least one payable upper building.");
     }
 
     @Test
@@ -1174,12 +1205,25 @@ class GameTest {
     void cardListsShouldReturnCopiesOfLists() {
         Game game = new Game(3);
 
-        List<TribeCard> upper = game.getUpperListTribeCards();
-        int originalSize = upper.size();
+        int upperTribeSize = game.getUpperListTribeCards().size();
+        int lowerTribeSize = game.getLowerListTribeCards().size();
+        int upperBuildingSize = game.getUpperListBuilding().size();
+        int lowerBuildingSize = game.getLowerListBuilding().size();
 
-        upper.clear();
+        List<TribeCard> upperTribe = game.getUpperListTribeCards();
+        List<TribeCard> lowerTribe = game.getLowerListTribeCards();
+        List<BuildingCard> upperBuilding = game.getUpperListBuilding();
+        List<BuildingCard> lowerBuilding = game.getLowerListBuilding();
 
-        assertEquals(originalSize, game.getUpperListTribeCards().size());
+        upperTribe.clear();
+        lowerTribe.clear();
+        upperBuilding.clear();
+        lowerBuilding.clear();
+
+        assertEquals(upperTribeSize, game.getUpperListTribeCards().size());
+        assertEquals(lowerTribeSize, game.getLowerListTribeCards().size());
+        assertEquals(upperBuildingSize, game.getUpperListBuilding().size());
+        assertEquals(lowerBuildingSize, game.getLowerListBuilding().size());
     }
 
     @Test
@@ -1197,4 +1241,213 @@ class GameTest {
         assertTrue(game.getPlayers().contains(p2));
     }
 
+    @Test
+    void skipDrawingShouldRejectOutsideResolvingActions() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "skip_out_");
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        assertFalse(game.SkipLowerDrawing(current));
+        assertFalse(game.SkipUpperDrawing(current));
+    }
+
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS)
+    void drawLowerBuildingShouldReturnFalseIfPlayerCannotPay() {
+        Game game = new Game(3);
+
+        addPlayers(game, 3, "no_food_lower_building_");
+
+        for (int safety = 0; safety < 300; safety++) {
+
+            if (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
+                completeSlotChoice(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                if (game.getCurrentState().getNLower() > 0
+                        && !game.getLowerListBuilding().isEmpty()) {
+
+                    BuildingCard selectedBuilding = game.getLowerListBuilding().get(0);
+
+                    if (selectedBuilding.getPrice() <= 0) {
+                        resolveOneMandatoryAction(game);
+                        continue;
+                    }
+
+                    while (current.getFoodValue() > 0) {
+                        assertTrue(current.removeFood(1));
+                    }
+
+                    current.builders.clear();
+
+                    assertEquals(0, current.getFoodValue());
+
+                    int buildingsBefore = current.buildingCards.size();
+                    int lowerBuildingsBefore = game.getLowerListBuilding().size();
+
+                    assertFalse(game.DrawLowerBuildingCardByIndex(current, 0));
+
+                    assertEquals(buildingsBefore, current.buildingCards.size());
+                    assertEquals(lowerBuildingsBefore, game.getLowerListBuilding().size());
+                    assertEquals(0, current.getFoodValue());
+
+                    return;
+                }
+
+                resolveOneMandatoryAction(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
+                resolveOptionalPhaseIfPresent(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.ENDED) {
+                break;
+            }
+        }
+
+        fail("The test never reached a state with NLower > 0 and at least one payable lower building.");
+    }
+
+    @Test
+    @Timeout(value = 5, unit = TimeUnit.SECONDS)
+    void drawLowerBuildingShouldRejectWrongPlayer() {
+        Game game = new Game(3);
+
+        List<Player> players = addPlayers(game, 3, "wrong_lower_building_");
+
+        for (int safety = 0; safety < 300; safety++) {
+
+            if (game.getCurrentState().getGameStage() == GameStages.SLOT_CHOICE) {
+                completeSlotChoice(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.RES_ACTIONS) {
+                Player current = game.getCurrentState().getCurrentPlayer();
+                assertNotNull(current);
+
+                if (game.getCurrentState().getNLower() > 0
+                        && !game.getLowerListBuilding().isEmpty()) {
+
+                    Player wrongPlayer = players.stream()
+                            .filter(p -> !p.equals(current))
+                            .findFirst()
+                            .orElseThrow();
+
+                    wrongPlayer.addFood(game.getLowerListBuilding().get(0).getPrice());
+
+                    assertFalse(game.DrawLowerBuildingCardByIndex(wrongPlayer, 0));
+                    return;
+                }
+
+                resolveOneMandatoryAction(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.OPT_CARD_E) {
+                resolveOptionalPhaseIfPresent(game);
+            }
+
+            if (game.getCurrentState().getGameStage() == GameStages.ENDED) {
+                break;
+            }
+        }
+
+        fail("The test never reached a lower building draw state.");
+    }
+
+    @Test
+    void cardListsShouldReturnClonedCards() {
+        Game game = new Game(3);
+
+        List<TribeCard> firstUpperTribeCall = game.getUpperListTribeCards();
+        List<TribeCard> secondUpperTribeCall = game.getUpperListTribeCards();
+
+        assertFalse(firstUpperTribeCall.isEmpty());
+        assertFalse(secondUpperTribeCall.isEmpty());
+
+        assertNotSame(firstUpperTribeCall.get(0), secondUpperTribeCall.get(0));
+
+        List<TribeCard> firstLowerTribeCall = game.getLowerListTribeCards();
+        List<TribeCard> secondLowerTribeCall = game.getLowerListTribeCards();
+
+        assertFalse(firstLowerTribeCall.isEmpty());
+        assertFalse(secondLowerTribeCall.isEmpty());
+
+        assertNotSame(firstLowerTribeCall.get(0), secondLowerTribeCall.get(0));
+
+        List<BuildingCard> firstUpperBuildingCall = game.getUpperListBuilding();
+        List<BuildingCard> secondUpperBuildingCall = game.getUpperListBuilding();
+
+        assertFalse(firstUpperBuildingCall.isEmpty());
+        assertFalse(secondUpperBuildingCall.isEmpty());
+
+        assertNotSame(firstUpperBuildingCall.get(0), secondUpperBuildingCall.get(0));
+    }
+
+    @Test
+    void initShouldAssignInitialFoodAccordingToOrderPosition() {
+        Game game = new Game(5);
+
+        Player p1 = new Player("p1");
+        Player p2 = new Player("p2");
+        Player p3 = new Player("p3");
+        Player p4 = new Player("p4");
+        Player p5 = new Player("p5");
+
+        assertTrue(game.addPlayer(p1));
+        assertTrue(game.addPlayer(p2));
+        assertTrue(game.addPlayer(p3));
+        assertTrue(game.addPlayer(p4));
+        assertTrue(game.addPlayer(p5));
+
+        assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
+
+        List<Integer> foodValues = game.getPlayers().stream()
+                .map(Player::getFoodValue)
+                .sorted()
+                .toList();
+
+        assertEquals(List.of(2, 3, 3, 4, 4), foodValues);
+    }
+
+    @Test
+    void slotChoiceShouldAddFoodWhenChoosingSlotAInFivePlayerGame() {
+        Game game = new Game(5);
+
+        addPlayers(game, 5, "slot_a_");
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        int foodBefore = current.getFoodValue();
+
+        assertTrue(game.SlotChoiceByIndex(current, 0));
+
+        assertEquals(foodBefore + 3, current.getFoodValue());
+    }
+
+    @Test
+    void slotChoiceShouldNotAddFoodWhenChoosingNonASlot() {
+        Game game = new Game(5);
+
+        addPlayers(game, 5, "slot_non_a_");
+
+        Player current = game.getCurrentState().getCurrentPlayer();
+        assertNotNull(current);
+
+        int foodBefore = current.getFoodValue();
+
+        assertTrue(game.SlotChoiceByIndex(current, 1));
+
+        assertEquals(foodBefore, current.getFoodValue());
+    }
 }
\ No newline at end of file