ZHAW-IT21b_WIN
/
gruppe06-hufflepuff-projekt3-catan
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added test classes for separation of purpose.

This commit is contained in:
MikeZyeman 2021-12-09 16:14:47 +01:00
parent 1bbb05ebfd
commit 5770d86a6f
2 changed files with 220 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.idea/misc.xml
View File

@ -1,6 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" languageLevel="JDK_X" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
<component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="openjdk-17" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

363
test/ch/zhaw/catan/SiedlerGameTest.java
View File

@ -7,10 +7,7 @@ import ch.zhaw.catan.games.ThreePlayerStandard;
import org.beryx.textio.TextIO;
import org.beryx.textio.TextIoFactory;
import org.beryx.textio.TextTerminal;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.*;
import java.awt.*;
import java.util.*;
@ -28,158 +25,236 @@ import java.util.List;
public class SiedlerGameTest {
private final static int DEFAULT_WINPOINTS = 10;
private final static int DEFAULT_WINPOINTS = 5;
private final static int DEFAULT_PLAYERAMOUNT = 4;
private final static Map<Config.Faction, Point> START_SETTLEMENT_POSITIONS = new HashMap<>(
Map.of(
Config.Faction.BLUE, new Point(5, 7),
Config.Faction.RED, new Point(1, 3),
Config.Faction.GREEN, new Point(11, 13),
Config.Faction.YELLOW, new Point(13, 5)
));
private final static Map<Config.Faction, Tuple<Point, Point>> START_ROADS_POSITIONS = new HashMap<>(
Map.of(
Config.Faction.BLUE, new Tuple<>(new Point(5, 6), new Point(5, 6)),
Config.Faction.RED, new Tuple<>(new Point(1, 2), new Point(1, 1)),
Config.Faction.GREEN, new Tuple<>(new Point(12, 12), new Point(13, 11)),
Config.Faction.YELLOW, new Tuple<>(new Point(13, 6), new Point(13, 7))
));
@Nested
@DisplayName("Positive test cases")
class PositiveTestcases {
/**
* To Test getLongestRoad in SiedlerBoard
*
*/
@Test
public void testLongestRoad() {
HashMap<Config.Faction,Integer> currentLongestRoad = new HashMap<>();
//currentLongestRoad.put(Config.Faction.RED,5);
List<Config.Faction> factionList = Arrays.asList(Config.Faction.values());
SiedlerBoard board = new SiedlerBoard();
board.createFixGamefield();
board.setEdge(new Point(6, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(6, 6),new Point(5, 7)));
board.setEdge(new Point(4, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(5, 7)));
board.setEdge(new Point(4, 6), new Point(4, 4), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(4, 4)));
board.setEdge(new Point(4, 6), new Point(3, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(3, 7)));
board.setEdge(new Point(3, 7), new Point(3, 9), new Road(Config.Faction.BLUE,new Point(3, 7),new Point(3, 9)));
board.setEdge(new Point(3, 9), new Point(4, 10), new Road(Config.Faction.BLUE,new Point(3, 9),new Point(4, 10)));
board.setEdge(new Point(4, 10), new Point(5, 9), new Road(Config.Faction.BLUE,new Point(4, 10),new Point(5, 9)));
board.setCorner(new Point(3,7),new Settlement(Config.Faction.BLUE,new Point(3,7)));
board.getLongestRoadFaction(currentLongestRoad,factionList);
assertEquals(6,currentLongestRoad.get(Config.Faction.BLUE));
}
/**
*
*/
@Test
@DisplayName("Test")
public void TestHandle7() {
SiedlerGame game = SystemTestcases.startGame();
}
}
@Nested
@DisplayName("Negative test cases")
class NegativeTestcases {
/**
* Tests if the method will fail when given false Data
* {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
*/
@Test
public void destructiveTestBuildCity() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
//Too
Assertions.assertFalse(model.buildCity(new Point(50, 60)));
//Factions wants to build a city on a city from another faction
Assertions.assertFalse(model.buildCity(new Point(3, 3)));
}
/**
* Tests if the method fails when given false Data
* {@link ThreePlayerStandard#getAfterSetupPhase(int)}
*/
@Test
public void destructiveTestBuildRoad() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhase(DEFAULT_WINPOINTS);
System.out.println(model.buildRoad(new Point(3, 7),new Point(3, 9)));
}
/**
* Tests if the method fails when trading material with the same material
* {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
*/
@Test
public void destructiveTestTradeWithBank() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
model.switchToNextPlayer();
Map<Config.Resource, Integer> expectedResourceCards = ThreePlayerStandard.BANK_ALMOST_EMPTY_RESOURCE_CARD_STOCK.get(model.getCurrentPlayerFaction());
assertEquals(expectedResourceCards.get(Config.Resource.WOOL), model.getCurrentPlayerResourceStock(Config.Resource.WOOL));
assertEquals(expectedResourceCards.get(Config.Resource.LUMBER), model.getCurrentPlayerResourceStock(Config.Resource.LUMBER));
System.out.println(model.tradeWithBankFourToOne(Config.Resource.WOOL, Config.Resource.WOOL));
}
}
/**
* To Test getLongestRoad in SiedlerBoard
* @Class SystemTestCases
*
* This class simulates a running game and tests multiple sequences of this game.
* Those test cases will be
*
*/
@Test
public void testLongestRoad() {
HashMap<Config.Faction,Integer> currentLongestRoad = new HashMap<>();
//currentLongestRoad.put(Config.Faction.RED,5);
List<Config.Faction> factionList = Arrays.asList(Config.Faction.values());
@Nested
@DisplayName("System test cases")
class SystemTestcases {
SiedlerBoard board = new SiedlerBoard();
board.createFixGamefield();
board.setEdge(new Point(6, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(6, 6),new Point(5, 7)));
board.setEdge(new Point(4, 6), new Point(5, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(5, 7)));
board.setEdge(new Point(4, 6), new Point(4, 4), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(4, 4)));
board.setEdge(new Point(4, 6), new Point(3, 7), new Road(Config.Faction.BLUE,new Point(4, 6),new Point(3, 7)));
board.setEdge(new Point(3, 7), new Point(3, 9), new Road(Config.Faction.BLUE,new Point(3, 7),new Point(3, 9)));
board.setEdge(new Point(3, 9), new Point(4, 10), new Road(Config.Faction.BLUE,new Point(3, 9),new Point(4, 10)));
board.setEdge(new Point(4, 10), new Point(5, 9), new Road(Config.Faction.BLUE,new Point(4, 10),new Point(5, 9)));
board.setCorner(new Point(3,7),new Settlement(Config.Faction.BLUE,new Point(3,7)));
board.getLongestRoadFaction(currentLongestRoad,factionList);
assertEquals(6,currentLongestRoad.get(Config.Faction.BLUE));
private final static Map<Config.Faction, Point> START_SETTLEMENT_POSITIONS = new HashMap<>(
Map.of(
Config.Faction.BLUE, new Point(4, 4),
Config.Faction.RED, new Point(10, 4),
Config.Faction.GREEN, new Point(4, 18),
Config.Faction.YELLOW, new Point(10, 18)
));
}
/**
* @Datafield START_ROADS_POSITION
*
* This are a set of Roads, that have been
*/
private final static Map<Config.Faction, Tuple<Point, Point>> START_ROADS_POSITIONS = new HashMap<>(
Map.of(
Config.Faction.BLUE, new Tuple<>(new Point(4, 4), new Point(4, 6)),
Config.Faction.RED, new Tuple<>(new Point(10, 4), new Point(10, 6)),
Config.Faction.GREEN, new Tuple<>(new Point(4, 18), new Point(4, 16)),
Config.Faction.YELLOW, new Tuple<>(new Point(10, 18), new Point(10, 16))
));
/**
* Tests if the method will fail when given false Data
* {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
*/
@Test
public void destructiveTestBuildCity() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
//Too
Assertions.assertFalse(model.buildCity(new Point(50, 60)));
//Factions wants to build a city on a city from another faction
Assertions.assertFalse(model.buildCity(new Point(3, 3)));
}
/**
* Tests if the method fails when given false Data
* {@link ThreePlayerStandard#getAfterSetupPhase(int)}
*/
@Test
public void destructiveTestBuildRoad() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhase(DEFAULT_WINPOINTS);
System.out.println(model.buildRoad(new Point(3, 7),new Point(3, 9)));
}
/**
* Tests if the method fails when trading material with the same material
* {@link ThreePlayerStandard#getAfterSetupPhaseAlmostEmptyBank(int)}
*/
@Test
public void destructiveTestTradeWithBank() {
SiedlerGame model = ThreePlayerStandard.getAfterSetupPhaseAlmostEmptyBank(DEFAULT_WINPOINTS);
model.switchToNextPlayer();
Map<Config.Resource, Integer> expectedResourceCards = ThreePlayerStandard.BANK_ALMOST_EMPTY_RESOURCE_CARD_STOCK.get(model.getCurrentPlayerFaction());
assertEquals(expectedResourceCards.get(Config.Resource.WOOL), model.getCurrentPlayerResourceStock(Config.Resource.WOOL));
assertEquals(expectedResourceCards.get(Config.Resource.LUMBER), model.getCurrentPlayerResourceStock(Config.Resource.LUMBER));
System.out.println(model.tradeWithBankFourToOne(Config.Resource.WOOL, Config.Resource.WOOL));
}
@Test
public void TestGameInSetupPhase() {
SiedlerGame game = startGame();
for (Config.Faction faction: game.getPlayerFactions()) {
HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
game.switchToNextPlayer();
}
}
@Test
public void TestGameAfterSetupPhase() {
SiedlerGame game = gameAfterSetupPhase();
throwDiceSeveralTimes(game, 5, 5);
System.out.println("\n\nVerteilung \n\n");
for (Config.Faction faction: game.getPlayerFactions()) {
HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
System.out.println(faction.toString() + "\n");
System.out.println(" BRICK " + resources.get(Config.Resource.BRICK).toString());
System.out.println(" GRAIN " + resources.get(Config.Resource.GRAIN));
System.out.println(" LUMBER " + resources.get(Config.Resource.LUMBER));
System.out.println(" ORE " + resources.get(Config.Resource.ORE));
System.out.println(" WOOL " + resources.get(Config.Resource.WOOL));
game.switchToNextPlayer();
}
}
@Test
public void TestGameInMiddle() {
}
private SiedlerGame startGame() {
return new SiedlerGame(DEFAULT_WINPOINTS, DEFAULT_PLAYERAMOUNT);
}
private void throwDiceSeveralTimes(SiedlerGame game, int dice, int amountDiceThrows) {
for (int i = 0; i < amountDiceThrows; i++) {
System.out.println(game.getCurrentPlayerFaction().toString());
game.throwDice(dice);
}
}
private SiedlerGame gameAfterSetupPhase() {
SiedlerGame game = startGame();
for (Config.Faction faction: game.getPlayerFactions()) {
game.buildSettlement(START_SETTLEMENT_POSITIONS.get(faction));
game.buildRoad(START_ROADS_POSITIONS.get(faction).first, START_ROADS_POSITIONS.get(faction).second);
game.switchToNextPlayer();
private static SiedlerGame startGame() {
return new SiedlerGame(DEFAULT_WINPOINTS, DEFAULT_PLAYERAMOUNT);
}
return game;
@Test
@DisplayName("Game initializing")
public void TestGameInitialization() {
SiedlerGame game = startGame();
for (Config.Faction faction: game.getPlayerFactions()) {
HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
game.switchToNextPlayer();
}
}
/**
* This will test when
*/
@Test
public void TestGameInSetupPhase() {
SiedlerGame game = gameInSetupPhase();
for (Config.Faction faction: game.getPlayerFactions()) {
HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
Assertions.assertEquals(0, resources.get(Config.Resource.BRICK));
Assertions.assertEquals(0, resources.get(Config.Resource.GRAIN));
Assertions.assertEquals(0, resources.get(Config.Resource.LUMBER));
Assertions.assertEquals(0, resources.get(Config.Resource.ORE));
Assertions.assertEquals(0, resources.get(Config.Resource.WOOL));
game.switchToNextPlayer();
}
}
private static SiedlerGame gameInSetupPhase() {
SiedlerGame game = startGame();
for (Config.Faction faction: game.getPlayerFactions()) {
game.placeInitialSettlement(START_SETTLEMENT_POSITIONS.get(faction), false);
game.placeInitialRoad(START_ROADS_POSITIONS.get(faction).first, START_ROADS_POSITIONS.get(faction).second);
game.switchToNextPlayer();
}
return game;
}
@Test
public void TestGameAfterSetupPhase() {
SiedlerGame game = gameAfterSetupPhase();
throwDiceSeveralTimes(game, 5, 5);
System.out.println("\n\nVerteilung \n\n");
for (Config.Faction faction: game.getPlayerFactions()) {
HashMap<Config.Resource, Integer> resources = game.getCurrentPlayerResource();
System.out.println(faction.toString() + "\n");
System.out.println(" BRICK " + resources.get(Config.Resource.BRICK).toString());
System.out.println(" GRAIN " + resources.get(Config.Resource.GRAIN));
System.out.println(" LUMBER " + resources.get(Config.Resource.LUMBER));
System.out.println(" ORE " + resources.get(Config.Resource.ORE));
System.out.println(" WOOL " + resources.get(Config.Resource.WOOL));
game.switchToNextPlayer();
}
}
private static SiedlerGame gameAfterSetupPhase() {
SiedlerGame game = gameInSetupPhase();
return game;
}
@Test
@DisplayName("End of Game test")
public void TestGameEnd() {
}
private static SiedlerGame gameNearEnd() {
SiedlerGame game = gameAfterSetupPhase();
return game;
}
private static void throwDiceSeveralTimes(SiedlerGame game, int dice, int amountDiceThrows) {
for (int i = 0; i < amountDiceThrows; i++) {
System.out.println(game.getCurrentPlayerFaction().toString());
game.throwDice(dice);
}
}
}
}