MatteoPellegrino05
635 lines
21 KiB
Java
635 lines
21 KiB
Java
package it.polimi.ingsw.gc14.Controller;
|
|
|
|
import it.polimi.ingsw.gc14.Model.Cards.BuildingCard;
|
|
import it.polimi.ingsw.gc14.Model.Cards.TribeCard;
|
|
import it.polimi.ingsw.gc14.Model.Game;
|
|
import it.polimi.ingsw.gc14.Model.GamePackage.GameStages;
|
|
import it.polimi.ingsw.gc14.Model.Player;
|
|
import org.junit.jupiter.api.Test;
|
|
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Queue;
|
|
|
|
import static org.junit.jupiter.api.Assertions.*;
|
|
|
|
class GameControllerTest {
|
|
|
|
private Game createStartedGame() {
|
|
Game game = new Game(3);
|
|
GameController controller = new GameController(game);
|
|
|
|
assertTrue(controller.addPlayer("Giorgio"));
|
|
assertTrue(controller.addPlayer("Marco"));
|
|
assertTrue(controller.addPlayer("Luca"));
|
|
|
|
return game;
|
|
}
|
|
|
|
private Queue<Player> completeSlotChoice(Game game, GameController controller) {
|
|
Queue<Player> order = new LinkedList<>();
|
|
|
|
for (int i = 0; i < game.getNPlayers(); i++) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
order.add(current);
|
|
|
|
assertTrue(controller.slotChoice(current.getUserName(), i));
|
|
}
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
return order;
|
|
}
|
|
|
|
private int firstNonEventIndex(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (!cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
fail("No non-event tribe card available.");
|
|
return -1;
|
|
}
|
|
|
|
private int firstEventIndexOrMinusOne(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private int firstNonEventIndexOrMinusOne(List<TribeCard> cards) {
|
|
for (int i = 0; i < cards.size(); i++) {
|
|
if (!cards.get(i).IsEventCard()) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
private void giveOptionalEffectToAllPlayers(Game game) {
|
|
Player first = game.getPlayerByUsername("Giorgio");
|
|
Player second = game.getPlayerByUsername("Marco");
|
|
Player third = game.getPlayerByUsername("Luca");
|
|
|
|
assertNotNull(first);
|
|
assertNotNull(second);
|
|
assertNotNull(third);
|
|
|
|
first.buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
second.buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
third.buildingCards.add(new BuildingCard(12, 1, 1, 0));
|
|
}
|
|
|
|
private void resolveActionsUntilOptionalCardEffect(Game game, GameController controller) {
|
|
int guard = 0;
|
|
|
|
while (game.getCurrentState().getGameStage() == GameStages.RESOLVING_ACTIONS && guard < 100) {
|
|
guard++;
|
|
resolveOneMandatoryAction(game, controller);
|
|
}
|
|
|
|
assertEquals(GameStages.OPTIONAL_CARD_EFFECT, game.getCurrentState().getGameStage());
|
|
}
|
|
|
|
private void resolveOneMandatoryAction(Game game, GameController controller) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
String username = current.getUserName();
|
|
|
|
if (game.getCurrentState().getNLower() > 0) {
|
|
int index = firstNonEventIndexOrMinusOne(game.getLowerListTribeCards());
|
|
|
|
if (index != -1) {
|
|
assertTrue(controller.drawLowerTribeCard(username, index));
|
|
return;
|
|
}
|
|
|
|
if (!game.getLowerListBuilding().isEmpty()) {
|
|
current.addFood(100);
|
|
assertTrue(controller.drawLowerBuildingCard(username, 0));
|
|
return;
|
|
}
|
|
|
|
assertTrue(controller.SkipLowerDrawing(username));
|
|
return;
|
|
}
|
|
|
|
if (game.getCurrentState().getNUpper() > 0) {
|
|
int index = firstNonEventIndexOrMinusOne(game.getUpperListTribeCards());
|
|
|
|
if (index != -1) {
|
|
assertTrue(controller.drawUpperTribeCard(username, index));
|
|
return;
|
|
}
|
|
|
|
if (!game.getUpperListBuilding().isEmpty()) {
|
|
current.addFood(100);
|
|
assertTrue(controller.drawUpperBuildingCard(username, 0));
|
|
return;
|
|
}
|
|
|
|
assertTrue(controller.SkipUpperDrawing(username));
|
|
return;
|
|
}
|
|
|
|
fail("Current player has no remaining draw actions.");
|
|
}
|
|
|
|
private Queue<Player> completeSlotChoiceWithSlots(Game game, GameController controller, int... slotIndexes) {
|
|
assertEquals(game.getNPlayers(), slotIndexes.length);
|
|
|
|
Queue<Player> order = new LinkedList<>();
|
|
|
|
for (int i = 0; i < game.getNPlayers(); i++) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
order.add(current);
|
|
|
|
assertTrue(controller.slotChoice(current.getUserName(), slotIndexes[i]));
|
|
}
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
return order;
|
|
}
|
|
|
|
|
|
@Test
|
|
void addPlayer() {
|
|
Game game = new Game(3);
|
|
GameController controller = new GameController(game);
|
|
|
|
assertTrue(controller.addPlayer("Giorgio"));
|
|
assertTrue(controller.addPlayer("Marco"));
|
|
assertTrue(controller.addPlayer("Luca"));
|
|
|
|
assertNotNull(game.getPlayerByUsername("Giorgio"));
|
|
assertNotNull(game.getPlayerByUsername("Marco"));
|
|
assertNotNull(game.getPlayerByUsername("Luca"));
|
|
|
|
assertEquals(GameStages.SLOT_CHOICE, game.getCurrentState().getGameStage());
|
|
assertFalse(controller.addPlayer("Extra"));
|
|
}
|
|
|
|
@Test
|
|
void allMethodsShouldReturnFalseForUnknownUsername() {
|
|
Game game = new Game(3);
|
|
GameController controller = new GameController(game);
|
|
|
|
assertFalse(controller.slotChoice("ghost", 0));
|
|
assertFalse(controller.drawUpperTribeCard("ghost", 0));
|
|
assertFalse(controller.drawLowerTribeCard("ghost", 0));
|
|
assertFalse(controller.drawUpperBuildingCard("ghost", 0));
|
|
assertFalse(controller.drawLowerBuildingCard("ghost", 0));
|
|
assertFalse(controller.SkipUpperDrawing("ghost"));
|
|
assertFalse(controller.SkipLowerDrawing("ghost"));
|
|
assertFalse(controller.pickOptionalTribeCard("ghost", 0));
|
|
assertFalse(controller.pickOptionalBuildingCard("ghost", 0));
|
|
assertFalse(controller.noOptionalCard("ghost"));
|
|
}
|
|
|
|
@Test
|
|
void slotChoice() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
String cur = game.getCurrentState().getCurrentPlayer().getUserName();
|
|
String other = cur.equals("Giorgio") ? "Marco" : "Giorgio";
|
|
|
|
assertFalse(controller.slotChoice(other, 0));
|
|
|
|
Queue<Player> order = completeSlotChoice(game, controller);
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
assertEquals(order.poll(), game.getCurrentState().getCurrentPlayer());
|
|
}
|
|
|
|
@Test
|
|
void drawLowerTribeCard() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
Queue<Player> order = completeSlotChoice(game, controller);
|
|
|
|
Player first = order.poll();
|
|
assertEquals(first, game.getCurrentState().getCurrentPlayer());
|
|
|
|
List<TribeCard> cards = game.getLowerListTribeCards();
|
|
int idx = firstNonEventIndex(cards);
|
|
|
|
Player wrongPlayer = order.peek();
|
|
assertNotNull(wrongPlayer);
|
|
|
|
assertFalse(controller.drawLowerTribeCard(wrongPlayer.getUserName(), idx));
|
|
|
|
int before = first.getTotCharacters();
|
|
|
|
assertTrue(controller.drawLowerTribeCard(first.getUserName(), idx));
|
|
|
|
assertEquals(before + 1, first.getTotCharacters());
|
|
}
|
|
|
|
@Test
|
|
void drawUpperTribeCard() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
|
|
while (game.getCurrentState().getNUpper() == 0) {
|
|
assertTrue(game.getCurrentState().getNLower() > 0);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
List<TribeCard> lower = game.getLowerListTribeCards();
|
|
int lowerIdx = firstNonEventIndex(lower);
|
|
|
|
assertTrue(controller.drawLowerTribeCard(current.getUserName(), lowerIdx));
|
|
}
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
int beforeTot = current.getTotCharacters();
|
|
|
|
List<TribeCard> upper = game.getUpperListTribeCards();
|
|
int upperIdx = firstNonEventIndex(upper);
|
|
|
|
assertTrue(controller.drawUpperTribeCard(current.getUserName(), upperIdx));
|
|
assertEquals(beforeTot + 1, current.getTotCharacters());
|
|
}
|
|
|
|
@Test
|
|
void drawUpperBuildingCard() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
|
|
while (game.getCurrentState().getNUpper() == 0) {
|
|
assertTrue(game.getCurrentState().getNLower() > 0);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
List<TribeCard> lower = game.getLowerListTribeCards();
|
|
int lowerIdx = firstNonEventIndex(lower);
|
|
|
|
assertTrue(controller.drawLowerTribeCard(current.getUserName(), lowerIdx));
|
|
}
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
while (current.getFoodValue() > 0) {
|
|
assertTrue(current.removeFood(1));
|
|
}
|
|
|
|
if (current.builders.isEmpty()) {
|
|
assertFalse(controller.drawUpperBuildingCard(current.getUserName(), 0));
|
|
}
|
|
|
|
current.addFood(100);
|
|
int foodBefore = current.getFoodValue();
|
|
int buildingsBefore = current.buildingCards.size();
|
|
|
|
assertTrue(controller.drawUpperBuildingCard(current.getUserName(), 0));
|
|
|
|
assertTrue(current.getFoodValue() <= foodBefore);
|
|
assertEquals(buildingsBefore + 1, current.buildingCards.size());
|
|
}
|
|
|
|
@Test
|
|
void drawingByIndexThroughController() {
|
|
Game game = new Game(3);
|
|
GameController controller = new GameController(game);
|
|
|
|
assertTrue(controller.addPlayer("p1"));
|
|
assertTrue(controller.addPlayer("p2"));
|
|
assertFalse(controller.addPlayer("p2"));
|
|
assertTrue(controller.addPlayer("p3"));
|
|
|
|
Queue<Player> players = new LinkedList<>();
|
|
|
|
for (int i = 0; i < game.getNPlayers(); i++) {
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
players.add(current);
|
|
|
|
assertTrue(controller.slotChoice(current.getUserName(), i));
|
|
}
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
Player tempPlayer = players.poll();
|
|
assertNotNull(tempPlayer);
|
|
assertEquals(tempPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
List<TribeCard> cards = game.getLowerListTribeCards();
|
|
int index = firstNonEventIndex(cards);
|
|
|
|
assertTrue(controller.drawLowerTribeCard(tempPlayer.getUserName(), index));
|
|
|
|
tempPlayer = players.poll();
|
|
assertNotNull(tempPlayer);
|
|
assertEquals(tempPlayer, game.getCurrentState().getCurrentPlayer());
|
|
|
|
while (game.getCurrentState().getNUpper() > 1) {
|
|
cards = game.getUpperListTribeCards();
|
|
|
|
index = firstNonEventIndexOrMinusOne(cards);
|
|
|
|
if (index == -1) {
|
|
break;
|
|
}
|
|
|
|
int before = tempPlayer.getTotCharacters();
|
|
|
|
assertTrue(controller.drawUpperTribeCard(tempPlayer.getUserName(), index));
|
|
|
|
assertEquals(before + 1, tempPlayer.getTotCharacters());
|
|
}
|
|
|
|
cards = game.getUpperListTribeCards();
|
|
|
|
int eventIndex = firstEventIndexOrMinusOne(cards);
|
|
|
|
if (eventIndex != -1) {
|
|
assertFalse(controller.drawUpperTribeCard(tempPlayer.getUserName(), eventIndex));
|
|
}
|
|
|
|
tempPlayer.addFood(100);
|
|
|
|
assertFalse(controller.drawUpperBuildingCard(tempPlayer.getUserName(), 999));
|
|
|
|
if (!game.getUpperListBuilding().isEmpty() && game.getCurrentState().getNUpper() > 0) {
|
|
assertTrue(controller.drawUpperBuildingCard(tempPlayer.getUserName(), 0));
|
|
}
|
|
|
|
cards = game.getUpperListTribeCards();
|
|
|
|
int nonEventIndex = firstNonEventIndexOrMinusOne(cards);
|
|
|
|
if (nonEventIndex != -1) {
|
|
assertFalse(controller.drawUpperTribeCard(tempPlayer.getUserName(), nonEventIndex));
|
|
}
|
|
}
|
|
|
|
@Test
|
|
void drawLowerBuildingCardShouldReturnFalseForUnavailableLowerBuildingCard() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertFalse(controller.drawLowerBuildingCard(current.getUserName(), 0));
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalCardsShouldReturnFalseOutsideOptionalCardEffectState() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
|
|
assertEquals(GameStages.RESOLVING_ACTIONS, game.getCurrentState().getGameStage());
|
|
|
|
String cur = game.getCurrentState().getCurrentPlayer().getUserName();
|
|
|
|
assertFalse(controller.pickOptionalTribeCard(cur, 0));
|
|
assertFalse(controller.pickOptionalBuildingCard(cur, 0));
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalTribeCardShouldWorkDuringOptionalCardEffectState() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
giveOptionalEffectToAllPlayers(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
resolveActionsUntilOptionalCardEffect(game, controller);
|
|
|
|
Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(optionalPlayer);
|
|
|
|
assertTrue(optionalPlayer.buildingCards.stream()
|
|
.anyMatch(building -> building.getEffectId() == 12));
|
|
|
|
List<TribeCard> upperCards = game.getUpperListTribeCards();
|
|
int index = firstNonEventIndex(upperCards);
|
|
|
|
int charactersBefore = optionalPlayer.getTotCharacters();
|
|
|
|
assertTrue(controller.pickOptionalTribeCard(optionalPlayer.getUserName(), index));
|
|
|
|
assertEquals(charactersBefore + 1, optionalPlayer.getTotCharacters());
|
|
}
|
|
|
|
@Test
|
|
void pickOptionalBuildingCardShouldWorkDuringOptionalCardEffectState() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
giveOptionalEffectToAllPlayers(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
resolveActionsUntilOptionalCardEffect(game, controller);
|
|
|
|
Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(optionalPlayer);
|
|
|
|
assertTrue(optionalPlayer.buildingCards.stream()
|
|
.anyMatch(building -> building.getEffectId() == 12));
|
|
|
|
assertFalse(game.getUpperListBuilding().isEmpty());
|
|
|
|
optionalPlayer.addFood(100);
|
|
|
|
int foodBefore = optionalPlayer.getFoodValue();
|
|
int buildingsBefore = optionalPlayer.buildingCards.size();
|
|
|
|
assertTrue(controller.pickOptionalBuildingCard(optionalPlayer.getUserName(), 0));
|
|
|
|
assertTrue(optionalPlayer.getFoodValue() <= foodBefore);
|
|
assertEquals(buildingsBefore + 1, optionalPlayer.buildingCards.size());
|
|
}
|
|
|
|
@Test
|
|
void addPlayerShouldRejectDuplicateUsername() {
|
|
Game game = new Game(3);
|
|
GameController controller = new GameController(game);
|
|
|
|
assertTrue(controller.addPlayer("Giorgio"));
|
|
assertFalse(controller.addPlayer("Giorgio"));
|
|
}
|
|
|
|
@Test
|
|
void drawingMethodsShouldReturnFalseForInvalidIndexes() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
String username = current.getUserName();
|
|
|
|
assertFalse(controller.drawLowerTribeCard(username, -1));
|
|
assertFalse(controller.drawLowerTribeCard(username, 999));
|
|
|
|
assertFalse(controller.drawUpperTribeCard(username, -1));
|
|
assertFalse(controller.drawUpperTribeCard(username, 999));
|
|
|
|
assertFalse(controller.drawLowerBuildingCard(username, -1));
|
|
assertFalse(controller.drawLowerBuildingCard(username, 999));
|
|
|
|
assertFalse(controller.drawUpperBuildingCard(username, -1));
|
|
assertFalse(controller.drawUpperBuildingCard(username, 999));
|
|
}
|
|
|
|
@Test
|
|
void slotChoiceShouldReturnFalseForAlreadyOccupiedSlot() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
Player first = game.getCurrentState().getCurrentPlayer();
|
|
assertTrue(controller.slotChoice(first.getUserName(), 0));
|
|
|
|
Player second = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertFalse(controller.slotChoice(second.getUserName(), 0));
|
|
}
|
|
|
|
@Test
|
|
void noOptionalCardShouldWorkDuringOptionalCardEffectState() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
giveOptionalEffectToAllPlayers(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
resolveActionsUntilOptionalCardEffect(game, controller);
|
|
|
|
Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(optionalPlayer);
|
|
|
|
assertTrue(optionalPlayer.buildingCards.stream()
|
|
.anyMatch(building -> building.getEffectId() == 12));
|
|
|
|
assertTrue(controller.noOptionalCard(optionalPlayer.getUserName()));
|
|
}
|
|
|
|
@Test
|
|
void constructorsGetModelAndSetModelShouldWork() {
|
|
Game game = new Game(3);
|
|
|
|
GameController controller = new GameController(game);
|
|
assertEquals(game, controller.getModel());
|
|
|
|
GameController emptyController = new GameController();
|
|
emptyController.setModel(game);
|
|
assertEquals(game, emptyController.getModel());
|
|
}
|
|
|
|
@Test
|
|
void slotChoiceShouldReturnFalseForInvalidIndexes() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
|
|
assertFalse(controller.slotChoice(current.getUserName(), -1));
|
|
assertFalse(controller.slotChoice(current.getUserName(), 999));
|
|
}
|
|
|
|
@Test
|
|
void optionalCardMethodsShouldReturnFalseForInvalidIndexesDuringOptionalCardEffectState() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
giveOptionalEffectToAllPlayers(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
resolveActionsUntilOptionalCardEffect(game, controller);
|
|
|
|
Player optionalPlayer = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(optionalPlayer);
|
|
|
|
String username = optionalPlayer.getUserName();
|
|
|
|
assertFalse(controller.pickOptionalTribeCard(username, -1));
|
|
assertFalse(controller.pickOptionalTribeCard(username, 999));
|
|
|
|
assertFalse(controller.pickOptionalBuildingCard(username, -1));
|
|
assertFalse(controller.pickOptionalBuildingCard(username, 999));
|
|
}
|
|
|
|
@Test
|
|
void optionalCardMethodsShouldReturnFalseForWrongPlayer() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
giveOptionalEffectToAllPlayers(game);
|
|
|
|
completeSlotChoice(game, controller);
|
|
resolveActionsUntilOptionalCardEffect(game, controller);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
Player wrongPlayer = game.getPlayers().stream()
|
|
.filter(player -> !player.equals(current))
|
|
.findFirst()
|
|
.orElse(null);
|
|
|
|
assertNotNull(wrongPlayer);
|
|
|
|
assertFalse(controller.pickOptionalTribeCard(wrongPlayer.getUserName(), 0));
|
|
assertFalse(controller.pickOptionalBuildingCard(wrongPlayer.getUserName(), 0));
|
|
assertFalse(controller.noOptionalCard(wrongPlayer.getUserName()));
|
|
}
|
|
|
|
@Test
|
|
void skipLowerDrawingShouldReturnFalseWhenLowerCharacterIsAvailable() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoiceWithSlots(game, controller, 0, 1, 2);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertEquals(1, game.getCurrentState().getNLower());
|
|
assertEquals(0, game.getCurrentState().getNUpper());
|
|
|
|
assertFalse(game.getLowerListTribeCards().isEmpty());
|
|
assertTrue(firstNonEventIndexOrMinusOne(game.getLowerListTribeCards()) != -1);
|
|
|
|
assertFalse(controller.SkipLowerDrawing(current.getUserName()));
|
|
}
|
|
|
|
@Test
|
|
void skipUpperDrawingShouldReturnFalseWhenUpperCharacterIsAvailable() {
|
|
Game game = createStartedGame();
|
|
GameController controller = new GameController(game);
|
|
|
|
completeSlotChoiceWithSlots(game, controller, 1, 2, 3);
|
|
|
|
Player current = game.getCurrentState().getCurrentPlayer();
|
|
assertNotNull(current);
|
|
|
|
assertEquals(0, game.getCurrentState().getNLower());
|
|
assertEquals(1, game.getCurrentState().getNUpper());
|
|
|
|
assertFalse(game.getUpperListTribeCards().isEmpty());
|
|
assertTrue(firstNonEventIndexOrMinusOne(game.getUpperListTribeCards()) != -1);
|
|
|
|
assertFalse(controller.SkipUpperDrawing(current.getUserName()));
|
|
}
|
|
|
|
|
|
}
|