rename packages lower case

src/test/java/server/BuildingManagerTest.java

@@ -0,0 +1,203 @@
+package server;
+
+import server.cards.CardDeck;
+import server.cards.CharacterCard;
+import server.cards.EventCard;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+class BuildingManagerTest {
+
+    static List<Player> players = new ArrayList<>();
+
+    @BeforeAll
+    static void setUp(){
+        BuildingManager buildingManager = new BuildingManager();
+
+        Player winner = new Player("Winner", TotemColor.YELLOW);
+        winner.addFood(10);
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;1;2;I;SHAMAN;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;2;2;I;SHAMAN;2;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;3;2;I;BUILDER;3;1"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;14;0;I;ARTIST;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;15;0;I;ARTIST;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;21;0;I;ARTIST;1;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;22;0;I;INVENTOR;9;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;23;4;I;INVENTOR;5;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;43;0;I;HUNTER;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;44;3;I;HUNTER;0;0"));
+        players.add(winner);
+
+        Player medium = new Player("Medium", TotemColor.RED);
+        medium.addFood(10);
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;56;2;I;SHAMAN;3;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;34;2;I;BUILDER;3;1"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;32;3;I;GATHERER;3;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;33;0;I;ARTIST;0;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;45;3;I;HUNTER;0;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;72;0;I;ARTIST;9;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;73;4;I;INVENTOR;5;0"));
+        players.add(medium);
+
+        Player loser = new Player("Loser", TotemColor.BLUE);
+        loser.addFood(2);
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;54;2;I;SHAMAN;3;0"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;36;2;I;BUILDER;3;1"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;82;0;I;INVENTOR;9;0"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;93;4;I;INVENTOR;5;0"));
+        players.add(loser);
+
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayerPath("./src/test/resources/files/only_building_deck.csv", 5);
+        cardDeck.setForNPlayer(BuildingManagerTest.class.getResourceAsStream("/files/only_building_deck.csv"), 4);
+        //for(BuildingCard c: cardDeck.drawBuilding(30)){
+        //    buildingManager.addActiveBuilding(c, players.getFirst());
+        //}
+        //buildingManager.addActiveBuilding(BuildingCard.parsRow("B;5;3;III;6;2;SHAMAN_NO_LOSS"), players.get(2));
+    }
+
+    @Test
+    void foodForSix() {
+        int initialFood = players.getFirst().getFoodTokens();
+        CharacterCard cardForSix = CharacterCard.parsRow("C;39;2;I;BUILDER;3;1");
+        BuildingManager.foodForSix(players.getFirst(), cardForSix);
+        assertEquals(initialFood + 6, players.getFirst().getFoodTokens());
+
+        players.getFirst().getPlayerTribe().addCharacter(cardForSix);
+        BuildingManager.foodForSix(players.getFirst(), cardForSix);
+        assertEquals(initialFood + 6, players.getFirst().getFoodTokens());
+    }
+
+    @Test
+    void sustainDiscount() {
+
+        EventCard sustainment = EventCard.parsRow("E;1;0;I;SUSTAINMENT;2;0");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getFoodTokens());
+        target.add(players.getFirst().getPrestigePoints());
+        target.add(players.get(1).getFoodTokens() - 4);
+        target.add(players.get(1).getPrestigePoints());
+        target.add(0);
+        target.add(players.get(2).getPrestigePoints()-4);
+        assertEquals(target, EventsSolver.sustainment(sustainment, players));
+    }
+
+    @Test
+    void shamanicBuildings() {
+        EventCard shamanicRitual =  EventCard.parsRow("E;1;0;I;SHAMANIC_RITUAL;10;5");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getPrestigePoints() + 20);
+        target.add(players.get(1).getPrestigePoints()-5);
+        target.add(players.get(2).getPrestigePoints());
+        assertEquals(target, EventsSolver.shamanicRitual(shamanicRitual, players));
+    }
+
+    @Test
+    void bonusEndTurn() {
+        assertEquals(1, BuildingManager.bonusEndTurn(players.getFirst(), 1));
+        assertEquals(0, BuildingManager.bonusEndTurn(players.getFirst(), 0));
+        assertEquals(0, BuildingManager.bonusEndTurn(players.getFirst(), -1));
+    }
+
+    @Test
+    void foodPerInventors() {
+        int initialFood = players.getFirst().getFoodTokens();
+        CharacterCard builder = CharacterCard.parsRow("C;57;2;I;INVENTOR;9;0");
+        BuildingManager.foodPerInventors(players.getFirst(), builder);
+        assertEquals(initialFood + 3, players.getFirst().getFoodTokens());
+
+        players.getFirst().getPlayerTribe().addCharacter(builder);
+        BuildingManager.foodPerInventors(players.getFirst(), builder);
+        assertEquals(initialFood+3, players.getFirst().getFoodTokens());
+
+        initialFood = players.get(2).getFoodTokens();
+        BuildingManager.foodPerInventors(players.get(2), builder);
+        assertEquals(initialFood, players.get(2).getFoodTokens());
+    }
+
+    @Test
+    void shamanBonus() {
+        assertEquals(3, BuildingManager.shamanBonus(players.getFirst()));
+        assertEquals(0, BuildingManager.shamanBonus(players.get(1)));
+    }
+
+    @Test
+    void hunterBonus() {
+        EventCard hunt = EventCard.parsRow("E;1;0;I;HUNT;2;0");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getFoodTokens()+4);
+        target.add(players.getFirst().getPrestigePoints()+6);
+        target.add(players.get(1).getFoodTokens()+1);
+        target.add(players.get(1).getPrestigePoints()+2);
+        target.add(players.get(2).getFoodTokens());
+        target.add(players.get(2).getPrestigePoints());
+        assertEquals(target, EventsSolver.hunt(hunt, players));
+    }
+
+    @Test
+    void endgameBuilderBonus() {
+    }
+
+    @Test
+    void paintingFoodBonus() {
+        int winnerInitial = players.getFirst().getFoodTokens();
+        int middleInitial = players.get(1).getFoodTokens();
+
+        EventCard cavePainting = EventCard.parsRow("E;4;4;FINAL;CAVE_PAINTINGS;2;2");
+        EventsSolver.cavePaintings(cavePainting, players);
+        assertEquals(winnerInitial + 3 , players.getFirst().getFoodTokens());
+        assertEquals(middleInitial, players.get(1).getFoodTokens());
+    }
+
+    @Test
+    void endgameForSix() {
+        int winnerInitial = players.getFirst().getPrestigePoints();
+        int middleInitial = players.get(1).getPrestigePoints();
+
+        BuildingManager.endgameForSix(players.getFirst());
+        BuildingManager.endgameForSix(players.get(1));
+        assertEquals(winnerInitial + 6 , players.getFirst().getPrestigePoints());
+        assertEquals(middleInitial, players.get(1).getPrestigePoints());
+    }
+
+    @Test
+    void endgameBonusCharacter() {
+        int winnerInitial = players.getFirst().getPrestigePoints();
+        int middleInitial = players.get(1).getPrestigePoints();
+
+        BuildingManager.endgameBonusCharacter(players.getFirst());
+        BuildingManager.endgameBonusCharacter(players.get(1));
+        assertEquals(winnerInitial + 9 , players.getFirst().getPrestigePoints());
+        assertEquals(middleInitial, players.get(1).getPrestigePoints());
+    }
+
+    @Test
+    void extraDraw() {
+        assertTrue(BuildingManager.extraDraw(players.getFirst()));
+        assertFalse(BuildingManager.extraDraw(players.get(1)));
+    }
+
+    @Test
+    void endgameBonusPoints() {
+        int initialWinner = players.getFirst().getPrestigePoints();
+        int initialMedium = players.get(1).getPrestigePoints();
+
+        BuildingManager.endgameBonusPoints(players.getFirst());
+        BuildingManager.endgameBonusPoints(players.get(1));
+        assertEquals(initialWinner+25, players.getFirst().getPrestigePoints());
+        assertEquals(initialMedium, players.get(1).getPrestigePoints());
+    }
+}

src/test/java/server/EventsSolverTest.java

@@ -0,0 +1,179 @@
+package server;
+
+import server.cards.Card;
+import server.cards.CardDeck;
+import server.cards.CharacterCard;
+import server.cards.EventCard;
+import server.utils.EventsManagerException;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class EventsSolverTest {
+
+    static List<Player> players = new ArrayList<>();
+
+    //Creating 4 players with a predefined tribe
+
+    @BeforeAll
+    public static void setUp(){
+        BuildingManager buildingManager = new BuildingManager();
+
+        Player winner = new Player("Winner", TotemColor.YELLOW);
+        winner.addFood(10);
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;1;2;I;SHAMAN;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;2;2;I;SHAMAN;2;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;3;2;I;BUILDER;3;1"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;12;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;13;3;I;GATHERER;3;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;14;0;I;ARTIST;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;15;0;I;ARTIST;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;21;0;I;ARTIST;1;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;22;0;I;INVENTOR;9;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;23;4;I;INVENTOR;5;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;43;0;I;HUNTER;0;0"));
+        winner.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;44;3;I;HUNTER;0;0"));
+        players.add(winner);
+
+        Player medium = new Player("Medium", TotemColor.RED);
+        medium.addFood(10);
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;56;2;I;SHAMAN;3;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;34;2;I;BUILDER;3;1"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;32;3;I;GATHERER;3;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;33;0;I;ARTIST;0;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;45;3;I;HUNTER;0;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;72;0;I;ARTIST;9;0"));
+        medium.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;73;4;I;INVENTOR;5;0"));
+        players.add(medium);
+
+        Player loser = new Player("Loser", TotemColor.BLUE);
+        loser.addFood(2);
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;54;2;I;SHAMAN;2;0"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;36;2;I;BUILDER;3;1"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;82;0;I;INVENTOR;9;0"));
+        loser.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;93;4;I;INVENTOR;5;0"));
+        players.add(loser);
+
+        Player loser2 = new Player("Loser2", TotemColor.PURPLE);
+        loser2.addFood(2);
+        loser2.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;54;2;I;SHAMAN;2;0"));
+        loser2.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;36;2;I;BUILDER;3;1"));
+        loser2.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;82;0;I;ARTIST;9;0"));
+        loser2.getPlayerTribe().addCharacter(CharacterCard.parsRow("C;93;4;I;INVENTOR;5;0"));
+        players.add(loser2);
+    }
+
+
+    //Testing if solveEvents is able to execute a series of events
+    @Test
+    void solveEvents() {
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayerPath("./src/test/resources/files/only_event_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/only_event_deck.csv"), 5);
+
+        List<EventCard> events = new ArrayList<>();
+        for(Card c: cardDeck.getTribeDeck()){
+            events.add((EventCard) c);
+        }
+
+        assertTrue(EventsSolver.solveEvents(events, players));
+
+    }
+
+    //Testing if sustainment is giving the correct output after inserting a valid input
+
+    @Test
+    void sustainment() {
+        EventCard sustainment = EventCard.parsRow("E;1;0;I;SUSTAINMENT;2;0");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getFoodTokens());
+        target.add(players.getFirst().getPrestigePoints());
+        target.add(players.get(1).getFoodTokens() - 4);
+        target.add(players.get(1).getPrestigePoints());
+        target.add(0);
+        target.add(players.get(3).getPrestigePoints()-8);
+        target.add(0);
+        target.add(players.get(3).getPrestigePoints()-8);
+        assertEquals(target, EventsSolver.sustainment(sustainment, players));
+
+    }
+
+    //Testing if hunt is giving the correct output after inserting a valid input
+
+    @Test
+    void hunt() {
+        EventCard hunt = EventCard.parsRow("E;1;0;I;HUNT;3;0");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getFoodTokens() + 2);
+        target.add(players.getFirst().getPrestigePoints() + 6);
+        target.add(players.get(1).getFoodTokens() + 1);
+        target.add(players.get(1).getPrestigePoints() + 3);
+        target.add(players.get(2).getFoodTokens());
+        target.add(players.get(2).getPrestigePoints());
+        target.add(players.get(3).getFoodTokens());
+        target.add(players.get(3).getPrestigePoints());
+        assertEquals(target, EventsSolver.hunt(hunt, players));
+
+    }
+
+    //Testing if shamanicRitual is giving the correct output after inserting a valid input
+
+    @Test
+    void shamanicRitual() {
+        EventCard shamanicRitual = EventCard.parsRow("E;1;0;I;SHAMANIC_RITUAL;10;5");
+
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getPrestigePoints() + 10);
+        target.add(players.get(1).getPrestigePoints());
+        target.add(players.get(2).getPrestigePoints()-5);
+        target.add(players.get(3).getPrestigePoints()-5);
+        assertEquals(target, EventsSolver.shamanicRitual(shamanicRitual, players));
+    }
+
+    //Testing if cavePainting is giving the correct output after inserting a valid input
+
+    @Test
+    void cavePaintings() {
+        EventCard cavePainting = EventCard.parsRow("E;4;4;FINAL;CAVE_PAINTINGS;2;2");
+        ArrayList<Integer> target = new ArrayList<>();
+        target.add(players.getFirst().getPrestigePoints() + 6);
+        target.add(players.get(1).getPrestigePoints() + 4);
+        target.add(players.get(2).getPrestigePoints()-2);
+        target.add(players.get(3).getPrestigePoints()-2);
+        assertEquals(target, EventsSolver.cavePaintings(cavePainting, players));
+    }
+
+    @Test
+    void wrongInputs(){
+        EventCard cavePainting = EventCard.parsRow("E;4;4;FINAL;CAVE_PAINTINGS;2;2");
+
+        Exception sustainmentException = assertThrows(EventsManagerException.class, () -> EventsSolver.sustainment(cavePainting, players));
+        String SustainmentMessage = sustainmentException.getMessage();
+        assertTrue(SustainmentMessage.contains("Not a sustainment card"));
+
+        Exception shamanicException = assertThrows(EventsManagerException.class, () -> EventsSolver.shamanicRitual(cavePainting, players));
+        String shamanicMessage = shamanicException.getMessage();
+        assertTrue(shamanicMessage.contains("Not a shamanic ritual card"));
+
+        Exception huntException = assertThrows(EventsManagerException.class, () -> EventsSolver.hunt(cavePainting, players));
+        String huntMessage = huntException.getMessage();
+        assertTrue(huntMessage.contains("Not a hunt card"));
+
+        EventCard sustainment = EventCard.parsRow("E;1;0;I;SUSTAINMENT;2;0");
+
+        Exception cavePaintingException = assertThrows(EventsManagerException.class, () -> EventsSolver.cavePaintings(sustainment, players));
+        String cavePaintingMessage = cavePaintingException.getMessage();
+        assertTrue(cavePaintingMessage.contains("Not a cave painting card"));
+
+    }
+}

src/test/java/server/GameBoardTest.java

@@ -0,0 +1,144 @@
+package server;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import server.*;
+import server.cards.CardDeck;
+
+import java.util.ArrayList;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.*;
+
+class GameBoardTest {
+
+    CardDeck deck = new CardDeck();
+    Player player1 = new Player("A", TotemColor.PURPLE);
+    Player player2 = new Player("B", TotemColor.YELLOW);
+    Player player3 = new Player("C", TotemColor.BLUE);
+    Player player4 = new Player("D", TotemColor.GREEN);
+    Player player5 = new Player("E", TotemColor.RED);
+    List<Player> players = new ArrayList<>();
+
+    @BeforeEach
+    void setUp() {
+        players.add(player1);
+        players.add(player2);
+        players.add(player3);
+        players.add(player4);
+        players.add(player5);
+        //deck.setForNPlayerPath(".\\src\\test\\resources\\files\\test_gameboard.csv",5);
+        deck.setForNPlayer(getClass().getResourceAsStream("/files/test_gameboard.csv"), 5);
+
+    }
+
+    @Test
+    void setTotemOnTile() {
+
+        //tests that the tile is occupied
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck, players.size());
+        Player player = new Player("Lucy", TotemColor.BLUE);
+        OfferingTile tile = new OfferingTile(4);
+        assertTrue(gameBoard.placeTotem(player,tile,gameBoard.getTurnTile() ));
+    }
+
+    @Test
+    void drawBottomCard() {
+
+        //test that a hunter card has been added to the player
+        CardDeck deck2 = new CardDeck();
+        //deck2.setForNPlayerPath("./src/test/resources/files/test_gameboard_characters.csv",5);
+        deck2.setForNPlayer(getClass().getResourceAsStream("/files/test_gameboard_characters.csv"), 5);
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck2,players.size());
+        Player player = new Player("Lucy", TotemColor.BLUE);
+        gameBoard.setupInitialRows(5);
+       // gameBoard.takeFromBottomRow(gameBoard.getBottomrow().get(2),player);
+       // assertEquals(1,player.getPlayerTribe().countCharactersByType(CharacterType.HUNTER));
+    }
+
+    @Test
+    void drawTopCard() {
+        //tests that a hunter card has been added to the player
+        CardDeck deck2 = new CardDeck();
+        //deck2.setForNPlayerPath("./src/test/resources/files/test_gameboard_characters.csv",5);
+        deck2.setForNPlayer(getClass().getResourceAsStream("/files/test_gameboard_characters.csv"), 5);
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck2,players.size());
+        Player player = new Player("Lucy", TotemColor.BLUE);
+        gameBoard.setupInitialRows(5);
+        //gameBoard.DrawTopCard(gameBoard.getToprow().get(2),player);
+        //assertEquals(1,player.getPlayerTribe().countCharactersByType(CharacterType.HUNTER));
+    }
+
+    @Test
+    void eventsToSolve() {
+
+        //tests that the result is a list of event cards
+        CardDeck deck2 = new CardDeck();
+       //deck2.setForNPlayerPath(".\\src\\test\\resources\\files\\test_gameboard_events.csv",5);
+        deck2.setForNPlayer(getClass().getResourceAsStream("/files/test_gameboard_events.csv"), 5);
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck2,players.size());
+
+        gameBoard.setupInitialRows(5);
+        //assertTrue(gameBoard.EventsToSolve().getFirst().getCardId() > 84);
+
+    }
+
+    @Test
+    void setRows() {
+        //tests that the top row has n+4 cards
+        GameBoard gameBoard = new GameBoard(Era.I,deck,players.size());
+        //assertEquals(9,gameBoard.SetRows(5).size());
+    }
+
+    @Test
+    void setOffersToNull() {
+
+        //tests that the tiles are free
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck,players.size());
+
+       // assertEquals(Collections.emptyList(),gameBoard.SetOffersToNull(5));
+
+    }
+
+    @Test
+    void nextEra() {
+
+        //tests that the eras progress
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck,players.size());
+       // assertEquals(Era.II,gameBoard.NextEra());
+
+    }
+
+    @Test
+    void changeBuildings() {
+
+        //tests that with era change the top row of building is of era II
+        CardDeck deck2 = new CardDeck();
+        //deck2.setForNPlayerPath(".\\src\\test\\resources\\files\\only_building_deck.csv",5);
+        deck2.setForNPlayer(getClass().getResourceAsStream("/files/only_building_deck.csv"), 5);
+
+        GameBoard gameBoard = new GameBoard(Era.II,deck2,players.size());
+
+        //assertEquals(Era.II,gameBoard.ChangeBuildings().getFirst().getEra());
+
+    }
+
+    @Test
+    void getBuilding() {
+
+        //tests that the building has gained the player as owner
+
+        GameBoard gameBoard = new GameBoard(Era.I,deck,players.size());
+        Player player = new Player("Diego",TotemColor.BLUE);
+        player.addFood(4);
+        //BuildingCard target = new BuildingCard(111,0,Era.II,4,3, Trigger.ENDGAME_BONUS_POINTS,null);
+        //assertEquals(target.getOwner(),gameBoard.GetBuilding(player,target).getOwner());
+    }
+
+
+}

src/test/java/server/OfferingTileTest.java

@@ -0,0 +1,64 @@
+package server;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class OfferingTileTest {
+
+    OfferingTile offeringTile;
+
+    @Test
+    void isEmpty() {
+
+     //test the ability of the method to recognize an occupied tile
+
+        OfferingTile offeringTile = new OfferingTile(4);
+
+        assertTrue(offeringTile.isEmpty());
+
+    }
+
+    @BeforeEach
+    public void init(){
+            offeringTile = new OfferingTile(4);
+            offeringTile.setOccupant(new Player("Johnny", TotemColor.BLUE));
+    }
+    @Test
+    void RemoveOccupant(){
+
+        //test that the occupant has been removed
+
+        assertNull(offeringTile.removeOccupant());
+    }
+
+    @Test
+    void GetOccupant(){
+
+        assertEquals("Johnny",offeringTile.getOccupant().getNickname());
+    }
+
+    @Test
+    void SetOccupant(){
+
+        //test that the player has been set
+
+
+        assertEquals("Johnny",offeringTile.getOccupant().getNickname());
+    }
+
+    @Test
+    void getActions(){
+
+        //tests that the actions associated to tile are the correct ones
+        OfferingTile offeringTile = new OfferingTile(4);
+
+        List<Symbol> correct = List.of(Symbol.DOWN,Symbol.UP);
+
+        assertEquals(correct,offeringTile.getActions());
+
+    }
+}

src/test/java/server/PlayerTest.java

@@ -0,0 +1,99 @@
+package server;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class PlayerTest {
+
+    @Test
+    @DisplayName("Dovrebbe aggiungere la quantità di cibo indicata")
+    void shouldAddFood() {
+        //Arrange
+        Player player = new Player("Giovanni", TotemColor.YELLOW);
+
+        //Act
+        player.addFood(5);
+        player.addFood(2);
+
+        //Assert
+        assertEquals(7, player.getFoodTokens(), "5 + 2 deve fare 7");
+    }
+
+    @Test
+    @DisplayName("Dovrebbe sottrarre il cibo quando i fondi sono sufficienti")
+    void shouldSubtractFoodWhenFundsAreSufficient() {
+        //Arrange
+        Player player = new Player("Mario", TotemColor.PURPLE);
+
+        //Act
+        player.addFood(5);
+        player.removeFood(2);
+
+        //Assert
+        assertEquals(3, player.getFoodTokens());
+    }
+
+    @Test
+    @DisplayName("Non dovrebbe far scendere il cibo sotto zero quando i fondi sono insufficienti")
+    void shouldNotGoNegativeWhenFoodIsInsufficient() {
+        //Arrange
+        Player player = new Player("Luigi", TotemColor.YELLOW);
+
+        //Act
+        player.addFood(2);
+        player.removeFood(5);
+
+        //Assert
+        assertEquals(2, player.getFoodTokens()); //Se il cibo è insufficiente, il cibo rimane lo stesso di prima, non diminuisce!
+    }
+
+    @Test
+    @DisplayName("Dovrebbe sommare correttamente i Punti Prestigio aggiunti")
+    void shouldAddPrestigePoints() {
+        // Arrange
+        Player player = new Player("Yoshi", TotemColor.YELLOW);
+
+        // Act
+        player.addPrestigePoints(3);
+        player.addPrestigePoints(4);
+        player.addPrestigePoints(10);
+
+        // Assert
+        assertEquals(17, player.getPrestigePoints());
+    }
+
+    @Test
+    @DisplayName("Dovrebbe sottrarre correttamente i Punti Prestigio persi")
+    void shouldRemovePrestigePoints() {
+        //Arrange
+        Player player = new Player("Gianbruno", TotemColor.BLUE);
+        player.addPrestigePoints(10);
+
+        // Act
+        player.removePrestigePoints(4);
+
+        // Assert
+        assertEquals(6, player.getPrestigePoints());
+    }
+
+    @Test
+    @DisplayName("Dovrebbe sottrarre correttamente i Punti Prestigio persi")
+    void shouldRemovePrestigePoints2() {
+        //Arrange
+        Player player1 = new Player("Gino", TotemColor.BLUE);
+        Player player2 = new Player("Olivia", TotemColor.RED);
+
+        player1.addPrestigePoints(10);
+        player2.addPrestigePoints(2);
+
+        // Act
+        player1.removePrestigePoints(4);
+        player2.removePrestigePoints(7);
+
+        // Assert
+        assertEquals(6, player1.getPrestigePoints());
+        assertEquals(-5, player2.getPrestigePoints());
+    }
+}

src/test/java/server/TribeTest.java

@@ -0,0 +1,129 @@
+package server;
+
+import server.cards.BuildingCard;
+import server.cards.CharacterCard;
+import server.cards.CharacterType;
+import server.cards.Trigger;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class TribeTest {
+    private Tribe tribe;
+
+    @BeforeEach
+    public void setUp(){
+        tribe = new Tribe(); // creiamo una tribù nuova prima di ogni test
+    }
+
+    @Test
+    public void testGathererDiscount() {
+        // 2 gatherer -> 6 cibi scontati
+        tribe.addCharacter(new CharacterCard(1, 2, Era.I, CharacterType.GATHERER, 3, 0));
+        tribe.addCharacter(new CharacterCard(2, 2, Era.I, CharacterType.GATHERER, 3, 0));
+
+        assertEquals(6,tribe.gathererDiscount());
+    }
+
+    @Test
+    public void testArtistsEndPoints() {
+        // 5 artisti = 2 coppie. 2 * 10 = 20 punti.
+        tribe.addCharacter(new CharacterCard(14, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(15, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(16, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(17, 3, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(18, 4, Era.I, CharacterType.ARTIST, 0, 0));
+
+        assertEquals(20, tribe.artistsEndPoints());
+    }
+
+    @Test
+    public void testInventorsEndPoints() {
+        // 3 Inventori, ma solo 2 invenzioni diverse: 2 (amo da pesca) e 3 (corda)
+        // 3 * 2= 6 punti
+        tribe.addCharacter(new CharacterCard(19, 2, Era.I, CharacterType.INVENTOR, 2, 0)); //statuetta
+        tribe.addCharacter(new CharacterCard(53, 2, Era.II, CharacterType.INVENTOR, 2, 0)); //statuetta
+        tribe.addCharacter(new CharacterCard(20, 2, Era.I, CharacterType.INVENTOR, 0, 0)); // canoa
+
+        assertEquals(6, tribe.inventorsEndPoints());
+    }
+
+    @Test
+    public void testBuildingBonusPoints() {
+        // Aggiungiamo l'edificio con id 117 che dà 25 punti
+        BuildingCard card25 = new BuildingCard(117, 2, Era.III, 10, 0, Trigger.ENDGAME_BONUS_POINTS, null);
+        tribe.addBuilding(card25);
+
+        // Se la tribù è vuota, dovrebbe dare esattamente 25 punti
+        assertEquals(25, tribe.endPoints(), "L'edificio bonus dovrebbe dare 25 punti");
+    }
+
+    @Test
+    public void testComplexScenario() {
+        // Due Artisti (1 coppia = 10 punti)
+        tribe.addCharacter(new CharacterCard(14, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(15, 2, Era.I, CharacterType.ARTIST, 0, 0));
+
+        // Un costruttore che vale 5 punti prestigio base
+        tribe.addCharacter(new CharacterCard(62, 2, Era.II, CharacterType.BUILDER, 1, 5));
+
+        // L'edificio che raddoppia i punti dei costruttori (card id: 107 - ENDGAME_BUILDER_BONUS)
+        BuildingCard doubleBuilderPoints = new BuildingCard(107, 2, Era.II, 6, 4, Trigger.ENDGAME_BUILDER_BONUS, null);
+        tribe.addBuilding(doubleBuilderPoints);
+
+        /* CALCOLO ATTESO:
+           - Artisti: 10 punti
+           - Costruttori base: 5 punti
+           - Bonus buildingAbilitiesEndPoints (buildersEndPoints * 2): 5 * 2 = 10 punti
+           - Buildings: 4 punti
+           TOTALE: 29 punti
+        */
+        assertEquals(29, tribe.endPoints(), "Il totale dovrebbe essere 29");
+    }
+
+    @Test
+    public void testComplexScenario2() {
+        // PERSONAGGI
+
+        // 3 Artisti (1 coppia = 10 punti)
+        tribe.addCharacter(new CharacterCard(14, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(15, 2, Era.I, CharacterType.ARTIST, 0, 0));
+        tribe.addCharacter(new CharacterCard(16, 2, Era.I, CharacterType.ARTIST, 0, 0));
+
+        // 2 Costruttori (7 punti base totali)
+        tribe.addCharacter(new CharacterCard(6, 2, Era.I, CharacterType.BUILDER, 1, 3));
+        tribe.addCharacter(new CharacterCard(36, 2, Era.II, CharacterType.BUILDER, 1, 4));
+
+        // 4 Inventori (2 del gruppo 1, 1 del gruppo 2, 1 del gruppo 3 -> 4*3 = 12 punti)
+        tribe.addCharacter(new CharacterCard(48, 2, Era.II, CharacterType.INVENTOR, 2, 0)); // Statuetta (iconValue=2)
+        tribe.addCharacter(new CharacterCard(76, 2, Era.III, CharacterType.INVENTOR, 2, 0)); // Statuetta
+        tribe.addCharacter(new CharacterCard(49, 4, Era.II, CharacterType.INVENTOR, 3, 0)); // Amo da pesca
+        tribe.addCharacter(new CharacterCard(23, 4, Era.I, CharacterType.INVENTOR, 5, 0)); // Corda
+
+        // Rimanenti per fare il set da 6
+        tribe.addCharacter(new CharacterCard(10, 2, Era.I, CharacterType.GATHERER, 3, 0));
+        tribe.addCharacter(new CharacterCard(11, 2, Era.I, CharacterType.GATHERER, 3, 0));
+        tribe.addCharacter(new CharacterCard(1, 2, Era.I, CharacterType.HUNTER, 1, 0));
+        tribe.addCharacter(new CharacterCard(27, 2, Era.I, CharacterType.SHAMAN, 2, 0));
+
+        // EDIFICI
+
+        // id 107 (Bonus Costruttori) - 4 Punti Base Edificio
+        tribe.addBuilding(new BuildingCard(107, 2, Era.II, 6, 4, Trigger.ENDGAME_BUILDER_BONUS, null));
+
+        // id 109 (Set da 6) - 6 Punti Base Edificio
+        tribe.addBuilding(new BuildingCard(109, 2, Era.II, 5, 6, Trigger.ENDGAME_FOR_SIX, null));
+
+        // id 112 (Bonus Sciamani) - 4 Punti Base Edificio
+        tribe.addBuilding(new BuildingCard(112, 2, Era.III, 7, 4, Trigger.ENDGAME_BONUS_CHARACTER, null));
+
+        // id 117 (25 Punti) - 0 Punti Base Edificio
+        tribe.addBuilding(new BuildingCard(117, 2, Era.III, 10, 0, Trigger.ENDGAME_BONUS_POINTS, null));
+
+
+        // VERIFICA
+        // Totale atteso = 92
+        assertEquals(92, tribe.endPoints(), "Il totale dovrebbe essere 92 punti");
+    }
+}

src/test/java/server/TurnTileOldTest.java

@@ -0,0 +1,62 @@
+package server;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TurnTileOldTest {
+    TurnTileOld turnTileOld;
+
+    Player player1 = new Player("A", TotemColor.PURPLE);
+    Player player2 = new Player("B", TotemColor.YELLOW);
+    Player player3 = new Player("C", TotemColor.BLUE);
+    Player player4 = new Player("D", TotemColor.GREEN);
+    Player player5 = new Player("E", TotemColor.RED);
+    List<Player> players = new ArrayList<>();
+    @BeforeEach
+    public void setUp(){
+
+        players.add(player1);
+        players.add(player2);
+        players.add(player3);
+        players.add(player4);
+        players.add(player5);
+        turnTileOld = new TurnTileOld(5);
+    }
+
+    @Test
+    void startOrder() {
+       assertEquals(5, turnTileOld.startOrder(players).length);
+
+    }
+
+    @Test
+    void giveReward() {
+        turnTileOld.startOrder(players);
+        player5.addFood(1);
+        assertEquals(0, turnTileOld.giveReward(player5).getFoodTokens());
+
+    }
+
+    @Test
+    void nextPlayer() {
+
+        //test that the method proceeds along the array
+        turnTileOld.startOrder(players);
+        assertEquals(player2, turnTileOld.nextPlayer());
+
+    }
+
+    @Test
+    void addPlayer() {
+
+        //verify that the first player changes
+
+        turnTileOld.startOrder(players);
+        assertEquals(player2, turnTileOld.addPlayer(player2));
+    }
+}

src/test/java/server/TurnTileTest.java

@@ -0,0 +1,52 @@
+package server;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class TurnTileTest {
+    TurnTile turnTile;
+
+    Player player1 = new Player("A", TotemColor.PURPLE);
+    Player player2 = new Player("B", TotemColor.YELLOW);
+    Player player3 = new Player("C", TotemColor.BLUE);
+    Player player4 = new Player("D", TotemColor.GREEN);
+    Player player5 = new Player("E", TotemColor.RED);
+    List<Player> players = new ArrayList<>();
+    @BeforeEach
+    public void setUp(){
+        players.add(player1);
+        players.add(player2);
+        players.add(player3);
+        players.add(player4);
+        players.add(player5);
+        turnTile = new TurnTile(5);
+    }
+
+    @Test
+    void startOrder() {
+       turnTile.setInitialOrder(players, false);
+       assertEquals(player1, turnTile.nextToPlace());
+        assertEquals(player2, turnTile.nextToPlace());
+        assertEquals(player3, turnTile.nextToPlace());
+        assertEquals(player4, turnTile.nextToPlace());
+        assertEquals(player5, turnTile.nextToPlace());
+
+    }
+
+    @Test
+    void giveReward() {
+        turnTile.setInitialOrder(players, false);
+        player5.addFood(1);
+        System.out.println(player5);
+        turnTile.returnTotem(player5);
+        System.out.println(player5);
+        assertEquals(0, player5.getFoodTokens());
+    }
+
+
+}

src/test/java/server/automaton/GameTest.java

@@ -0,0 +1,34 @@
+package server.automaton;
+
+import org.junit.jupiter.api.Test;
+
+class GameTest {
+
+    @Test
+    void newGame() {
+    }
+
+    @Test
+    void placeTotem() {
+    }
+
+    @Test
+    void resolveCardAction() {
+    }
+
+    @Test
+    void extraDrawAction() {
+    }
+
+    @Test
+    void skipExtraDraw() {
+    }
+
+    @Test
+    void endGame() {
+    }
+
+    @Test
+    void getPendingActions() {
+    }
+}

src/test/java/server/cards/BuildingCardTest.java

@@ -0,0 +1,39 @@
+package server.cards;
+
+import org.junit.jupiter.api.Test;
+
+import static server.Era.I;
+import static server.Era.II;
+import static org.junit.jupiter.api.Assertions.*;
+
+class BuildingCardTest {
+
+
+    //Test if the method parsRow is able to create a correct BuildingCard
+    @Test
+    void registerBuildingCard() {
+        BuildingCard buildingCard = BuildingCard.parsRow("B;1;2;I;3;1;SHAMAN_BONUS");
+
+        assertEquals(1, buildingCard.getCardId());
+        assertEquals(2, buildingCard.getForMinPlayer());
+        assertEquals(I, buildingCard.getEra());
+        assertEquals(3, buildingCard.getCost());
+        assertEquals(1, buildingCard.getCardId());
+        assertEquals(Trigger.SHAMAN_BONUS, buildingCard.getAbilityTrigger());
+        assertNull(buildingCard.getEffectTarget());
+    }
+
+    void registerBuildingCardWithTarget() {
+        BuildingCard buildingCard = BuildingCard.parsRow("B;17;5;II;6;2;SUSTAIN_DISCOUNT;ARTIST");
+
+        assertEquals(17, buildingCard.getCardId());
+        assertEquals(5, buildingCard.getForMinPlayer());
+        assertEquals(II, buildingCard.getEra());
+        assertEquals(6, buildingCard.getCost());
+        assertEquals(2, buildingCard.getCardId());
+        assertEquals(Trigger.SUSTAIN_DISCOUNT, buildingCard.getAbilityTrigger());
+        assertEquals(CharacterType.ARTIST, buildingCard.getEffectTarget());
+    }
+
+
+}

src/test/java/server/cards/CardDeckTest.java

@@ -0,0 +1,111 @@
+package server.cards;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import server.Era;
+
+import static org.junit.jupiter.api.Assertions.*;
+class CardDeckTest {
+
+    //Load 2 cards from CSV to cardDeck
+    @Test
+    void loadOnlyCharacter(){
+        CardDeck cardDeck = new CardDeck();
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/cards.csv"), 4);
+        assertEquals(2, cardDeck.getTribeDeck().size());
+    }
+
+    //First create a new CardDeck filled with a 14 cards then he recreates said deck
+    // with a different set of cards to emulate a new game
+    @Test
+    void doubleLoad(){
+        CardDeck cardDeck = new CardDeck();
+
+        //cardDeck.setForNPlayer("./src/test/resources/files/only_building_deck.csv", 4);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/only_building_deck.csv"), 4);
+        assertEquals(0, cardDeck.getTribeDeck().size());
+        assertEquals(6, cardDeck.getBuildingDeck(Era.I).size());
+        assertEquals(7, cardDeck.getBuildingDeck(Era.II).size());
+        assertEquals(8, cardDeck.getBuildingDeck(Era.III).size());
+
+        //cardDeck.setForNPlayer("./src/test/resources/files/only_event_deck.csv", 4);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/only_event_deck.csv"), 4);
+        assertEquals(3, cardDeck.getTribeDeck().size());
+        assertEquals(0, cardDeck.getBuildingDeck(Era.I).size());
+        assertEquals(0, cardDeck.getBuildingDeck(Era.II).size());
+        assertEquals(0, cardDeck.getBuildingDeck(Era.III).size());
+    }
+
+    //Draw 5 cards from TribeDeck and 3 from BuildingDeck, then check if they are correctly
+    // removed from cardDeck
+    @Test
+    void draw() {
+
+        int tribeDraw = 5;
+        int buildingDraw = 3;
+        int drawnCards = tribeDraw + buildingDraw;
+
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayer("./src/test/resources/files/test_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/test_deck.csv"), 5);
+
+        //int deckSize = cardDeck.getTribeDeck().size() +  cardDeck.getBuildingDeck().size();
+
+        List<Card> cards = cardDeck.drawTribe(tribeDraw);
+        assertEquals(tribeDraw, cards.size());
+        //List<BuildingCard> buildingCards = cardDeck.drawBuilding(buildingDraw);
+        //assertEquals(buildingDraw, buildingCards.size());
+
+        //int newDeckSize = cardDeck.getTribeDeck().size() +  cardDeck.getBuildingDeck().size();
+        //assertEquals(deckSize - drawnCards, newDeckSize);
+    }
+
+    //draw 5 cards from TribeDeck
+    @Test
+    void drawTribe() {
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayer("./src/test/resources/files/test_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/test_deck.csv"), 5);
+        List<Card> cards = cardDeck.drawTribe(5);
+        assertEquals(5, cards.size());
+    }
+
+    //draw 3 cards from BuildingDeck
+    @Test
+    void drawBuilding() {
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayer("./src/test/resources/files/test_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/test_deck.csv"), 5);
+
+       // List<BuildingCard> buildingCards = cardDeck.drawBuilding(3);
+       // assertEquals(3, buildingCards.size());
+    }
+
+    //Try to draw 5 cards from a deck of only 3, then he returns only the remaining
+    //cards in the deck
+    @Test
+    void drawTooManyCards() {
+        CardDeck cardDeck = new CardDeck();
+        //cardDeck.setForNPlayer("./src/test/resources/files/only_character_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/only_character_deck.csv"), 5);
+
+        List<Card> cards = cardDeck.drawTribe(5);
+        assertEquals(3, cards.size());
+    }
+
+
+    @Test
+    void shuffledDeck() {
+        CardDeck cardDeck = new CardDeck();
+       // cardDeck.setForNPlayer("./src/test/resources/files/test_deck.csv", 5);
+        cardDeck.setForNPlayer(getClass().getResourceAsStream("/files/test_deck.csv"), 5);
+
+        assertEquals(Era.I, cardDeck.drawTribe(1).getFirst().getEra());
+        assertEquals(Era.FINAL, cardDeck.drawTribe(100).getLast().getEra());
+
+      //  assertEquals(Era.I, cardDeck.drawBuilding(1).getFirst().getEra());
+      //  assertEquals(Era.III, cardDeck.drawBuilding(100).getLast().getEra());
+    }
+}

src/test/java/server/cards/CharacterCardTest.java

@@ -0,0 +1,36 @@
+package server.cards;
+
+import server.utils.LoadingCardsException;
+import org.junit.jupiter.api.Test;
+
+import static server.Era.I;
+import static org.junit.jupiter.api.Assertions.*;
+
+class CharacterCardTest {
+
+    //Test if the method parsRow is able to create a correct CharacterCard
+    @Test
+    void parsRow() {
+        CharacterCard characterCard = CharacterCard.parsRow("C;1;2;I;SHAMAN;3;4");
+
+        assertEquals(1, characterCard.getCardId());
+        assertEquals(2, characterCard.getForMinPlayer());
+        assertEquals(I, characterCard.getEra());
+        assertEquals(CharacterType.SHAMAN, characterCard.getCharacterType());
+        assertEquals(3, characterCard.getIconValue());
+        assertEquals(4, characterCard.getPrestigePoints());
+    }
+
+    //Tests if the method parsRow send an exception with the message "Not a character" when is given
+    //as an input the wrong type of card
+
+    @Test
+    void wrongTypeOfCard(){
+        Exception exception = assertThrows(LoadingCardsException.class, () -> CharacterCard.parsRow("B;1;2;I;3;1;SHAMANIC_RITUAL"));
+
+        String actualMessage = exception.getMessage();
+        assertTrue(actualMessage.contains("Not a character card"));
+
+    }
+
+}

src/test/java/server/cards/EventCardTest.java

@@ -0,0 +1,34 @@
+package server.cards;
+
+import server.utils.LoadingCardsException;
+import org.junit.jupiter.api.Test;
+
+import static server.Era.I;
+import static org.junit.jupiter.api.Assertions.*;
+
+class EventCardTest {
+
+    //Test if the method parsRow is able to create a correct EventCard
+    @Test
+    void parsRow() {
+        EventCard eventCard = EventCard.parsRow("E;1;2;I;CAVE_PAINTINGS;3;4");
+
+        assertEquals(1, eventCard.getCardId());
+        assertEquals(2, eventCard.getForMinPlayer());
+        assertEquals(I, eventCard.getEra());
+        assertEquals(Event.CAVE_PAINTINGS, eventCard.getEvent());
+        assertEquals(3, eventCard.getFirstValue());
+        assertEquals(4, eventCard.getSecondValue());
+    }
+
+    //Tests if the method parsRow send an exception with the message "Not an EventCard" when is given
+    //as an input the wrong type of card
+
+    @Test
+    void wrongTypeOfCard(){
+        Exception exception = assertThrows(LoadingCardsException.class, () -> EventCard.parsRow("B;1;2;I;3;1;SHAMANIC_RITUAL"));
+
+        String actualMessage = exception.getMessage();
+        assertTrue(actualMessage.contains("Not an EventCard"));
+    }
+}