Aleandro/Progetto-ingegneria-del-software
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix: GameTest

Browse Source
This commit is contained in:
MatteoPellegrino05
2026-04-25 17:10:49 +02:00
parent aee1d3ad87
commit ee87efcc48
1 changed files with 291 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/it/polimi/ingsw/gc14/Model/GameTest.java
+291 -157
View File
@@ -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) {
p1.buildingCards.add(new BuildingCard(12, 1, 1, 0));
p2.buildingCards.add(new BuildingCard(12, 1, 1, 0));
p3.buildingCards.add(new BuildingCard(12, 1, 1, 0));
private void giveOptionalEffectToAllPlayers(Player... players) {
for (Player player : players) {
player.buildingCards.add(new BuildingCard(12, 1, 1, 0));
}
}
private void resolveAllMandatoryActions(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.");
}
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) {
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.");
}
} else if (game.getCurrentState().getNUpper() > 0) {
int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
if (index != -1) {
assertTrue(game.DrawUpperTribeCardByIndex(current, index));
} 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 < 20) {
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 50) {
guard++;
Player current = game.getCurrentState().getCurrentPlayer();
assertNotNull(current);
if (game.getCurrentState().getNLower() > 0) {
int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
if (index == -1) {
fail("No lower non-event tribe 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 {
current.addFood(100);
assertTrue(game.DrawUpperBuildingCardByIndex(current, 0));
}
} else {
fail("Current player has no remaining draws.");
}
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,49 +124,73 @@ class GameTest {
}
}
@Test void Game()
{
int nPlayers = 3;
Game game=new Game(nPlayers);
assertEquals(nPlayers,game.getNPlayers());
assertEquals(GameStages.WAITING,game.getCurrentState().getGameStage());
private static class FinalTestBuildingCard extends BuildingCard {
assertThrows(IllegalArgumentException.class,()->new Game(6));
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();
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());
assertEquals(nPlayers, game.getNPlayers());
assertEquals(GameStages.WAITING, game.getCurrentState().getGameStage());
}
@Test
void getUpperListTribeCards() {
int nPlayers = 3;
Game game=new Game(nPlayers);
assertEquals(nPlayers+4 ,game.getUpperListTribeCards().size());
Game game = new Game(nPlayers);
assertEquals(nPlayers + 4, game.getUpperListTribeCards().size());
}
@Test
void getUpperListBuildingCards() {
int nPlayers = 3;
Game game=new Game(nPlayers);
assertEquals(2 ,game.getUpperListBuilding().size());
Game game = new Game(nPlayers);
assertEquals(2, game.getUpperListBuilding().size());
}
@Test
void getLowerListBuildingCards() {
int nPlayers = 3;
Game game=new Game(nPlayers);
assertEquals(0 ,game.getLowerListBuilding().size());
Game game = new Game(nPlayers);
assertEquals(0, game.getLowerListBuilding().size());
}
@Test
void getLowerListTribeCards() {
int nPlayers = 3;
Game game=new Game(nPlayers);
assertEquals(nPlayers+1 ,game.getLowerListTribeCards().size());
Game game = new Game(nPlayers);
assertEquals(nPlayers + 1, game.getLowerListTribeCards().size());
}
@@ -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");
@@ -229,45 +262,50 @@ class GameTest {
@Test
void drawingByIndex() {
Game game=new Game(3);
Player p1=new Player("p1");
Player p2=new Player("p2");
Player p3=new Player("p3");
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));
assertFalse(game.addPlayer(p2));
assertTrue(game.addPlayer(p3));
Queue<Player>players=new LinkedList<>();
for(int i=0;i<3;i++) {
players.add( game.getCurrentState().getCurrentPlayer());
Queue<Player> players = new LinkedList<>();
for (int i = 0; i < 3; i++) {
players.add(game.getCurrentState().getCurrentPlayer());
assertTrue(game.SlotChoiceByIndex(game.getCurrentState().getCurrentPlayer(), i));
}
Player temp_player;
temp_player=players.poll();
assertEquals(temp_player,game.getCurrentState().getCurrentPlayer());
temp_player = players.poll();
assertEquals(temp_player, game.getCurrentState().getCurrentPlayer());
int index;
List<TribeCard> cards=game.getLowerListTribeCards();
List<TribeCard> cards = game.getLowerListTribeCards();
index=cards.indexOf(cards.stream().filter(x->!x.IsEventCard()).findFirst().get());
assertTrue(game.DrawLowerTribeCardByIndex(temp_player,index));
index = firstNonEventIndex(cards);
assertTrue(game.DrawLowerTribeCardByIndex(temp_player, index));
temp_player=players.poll();
assertEquals(temp_player,game.getCurrentState().getCurrentPlayer());
int nCards=game.getUpperListTribeCards().size();
int countCards=0;
HashMap<CharacterType,Integer>nCardsByType=new HashMap<CharacterType, Integer>();
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=cards.indexOf(temp_card);
assertEquals(nCards-countCards,game.getUpperListTribeCards().size()-countCards);
drawTribeTest(nCardsByType,nCards,countCards,temp_card,temp_player,game);
assertTrue(game.DrawUpperTribeCardByIndex(temp_player,index));
temp_player = players.poll();
assertEquals(temp_player, game.getCurrentState().getCurrentPlayer());
int nCards = game.getUpperListTribeCards().size();
int countCards = 0;
HashMap<CharacterType, Integer> nCardsByType = new HashMap<CharacterType, Integer>();
Arrays.stream(CharacterType.values()).forEach(type -> nCardsByType.put(type, 0));
while (game.getCurrentState().getNUpper() > 1) {
cards = game.getUpperListTribeCards();
index = firstNonEventIndexOrMinusOne(cards);
if (index == -1) {
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,42 +314,50 @@ 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);
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));
assertFalse(game.getUpperListBuilding().isEmpty());
index = 0;
assertTrue(game.DrawUpperBuildingCardByIndex(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) {
switch (((Character)temp_card).getType()) {
case CharacterType.ARTIST:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.artists.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
private void drawTribeTest(HashMap<CharacterType, Integer> nCardsByType,
TribeCard temp_card,
Player temp_player) {
switch (((Character) temp_card).getType()) {
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:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.inventors.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
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:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.hunters.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
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:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.shamans.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
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:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.builders.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
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:
assertEquals( nCardsByType.get(((Character)temp_card).getType())+1,temp_player.gatherers.size());
nCardsByType.merge(((Character)temp_card).getType(),1,Integer::sum);
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());
});
}
}