Skip to content
Snippets Groups Projects
Commit c881a632 authored by Ola Leifler's avatar Ola Leifler
Browse files

Reset limit as cleanup after test

parent b4f8127b
Branches
No related tags found
No related merge requests found
...@@ -19,6 +19,8 @@ ...@@ -19,6 +19,8 @@
package net.sf.freecol.common.model; package net.sf.freecol.common.model;
import org.junit.After;
import net.sf.freecol.common.model.GameOptions; import net.sf.freecol.common.model.GameOptions;
import net.sf.freecol.common.model.Operand.OperandType; import net.sf.freecol.common.model.Operand.OperandType;
import net.sf.freecol.common.model.Operand.ScopeLevel; import net.sf.freecol.common.model.Operand.ScopeLevel;
...@@ -27,165 +29,203 @@ import net.sf.freecol.server.model.ServerBuilding; ...@@ -27,165 +29,203 @@ import net.sf.freecol.server.model.ServerBuilding;
import net.sf.freecol.server.model.ServerUnit; import net.sf.freecol.server.model.ServerUnit;
import net.sf.freecol.util.test.FreeColTestCase; import net.sf.freecol.util.test.FreeColTestCase;
public class LimitTest extends FreeColTestCase { public class LimitTest extends FreeColTestCase {
public void testOperand() { public void testOperand() {
UnitType carpenter = spec().getUnitType("model.unit.masterCarpenter"); UnitType carpenter = spec().getUnitType("model.unit.masterCarpenter");
UnitType frigate = spec().getUnitType("model.unit.frigate"); UnitType frigate = spec().getUnitType("model.unit.frigate");
Operand operand = new Operand(); Operand operand = new Operand();
assertEquals(OperandType.NONE, operand.getOperandType()); assertEquals(OperandType.NONE, operand.getOperandType());
assertEquals(ScopeLevel.NONE, operand.getScopeLevel()); assertEquals(ScopeLevel.NONE, operand.getScopeLevel());
operand.setType("model.unit.frigate"); operand.setType("model.unit.frigate");
assertTrue(operand.appliesTo(frigate)); assertTrue(operand.appliesTo(frigate));
assertFalse(operand.appliesTo(carpenter)); assertFalse(operand.appliesTo(carpenter));
} }
public void testWagonTrainLimit() { public void testWagonTrainLimit() {
Game game = getStandardGame(); Game game = getStandardGame();
Player dutch = game.getPlayerByNationId("model.nation.dutch"); Player dutch = game.getPlayerByNationId("model.nation.dutch");
Map map = getTestMap(); Map map = getTestMap();
game.setMap(map); game.setMap(map);
Colony colony = getStandardColony(3); Colony colony = getStandardColony(3);
Building armory = new ServerBuilding(getGame(), colony, spec().getBuildingType("model.building.armory")); Building armory = new ServerBuilding(getGame(), colony, spec()
colony.addBuilding(armory); .getBuildingType("model.building.armory"));
colony.addBuilding(armory);
UnitType wagonTrain = spec().getUnitType("model.unit.wagonTrain");
UnitType artillery = spec().getUnitType("model.unit.artillery"); UnitType wagonTrain = spec().getUnitType("model.unit.wagonTrain");
UnitType artillery = spec().getUnitType("model.unit.artillery");
Limit wagonTrainLimit = wagonTrain.getLimits().get(0);
Limit wagonTrainLimit = wagonTrain.getLimits().get(0);
assertTrue(colony.canBuild(artillery));
assertFalse(wagonTrainLimit.getLeftHandSide().appliesTo(artillery)); assertTrue(colony.canBuild(artillery));
assertFalse(wagonTrainLimit.getLeftHandSide().appliesTo(artillery));
assertTrue(wagonTrainLimit.evaluate(colony));
assertTrue(colony.canBuild(wagonTrain)); assertTrue(wagonTrainLimit.evaluate(colony));
assertTrue(colony.canBuild(wagonTrain));
Unit wagon = new ServerUnit(game, colony.getTile(), dutch, wagonTrain);
assertNotNull(wagon); Unit wagon = new ServerUnit(game, colony.getTile(), dutch, wagonTrain);
assertEquals(Colony.NoBuildReason.LIMIT_EXCEEDED, assertNotNull(wagon);
colony.getNoBuildReason(wagonTrain, null)); assertEquals(Colony.NoBuildReason.LIMIT_EXCEEDED,
assertFalse(wagonTrainLimit.evaluate(colony)); colony.getNoBuildReason(wagonTrain, null));
assertFalse(colony.canBuild(wagonTrain)); assertFalse(wagonTrainLimit.evaluate(colony));
assertTrue(colony.canBuild(artillery)); assertFalse(colony.canBuild(wagonTrain));
} assertTrue(colony.canBuild(artillery));
}
public void testIndependenceLimits() {
Game game = getStandardGame(); public void testIndependenceLimits() {
Player dutch = game.getPlayerByNationId("model.nation.dutch"); Game game = getStandardGame();
Map map = getTestMap(); Player dutch = game.getPlayerByNationId("model.nation.dutch");
game.setMap(map); Map map = getTestMap();
game.setMap(map);
Colony colony = getStandardColony(3);
Colony colony = getStandardColony(3);
Event event = spec().getEvent("model.event.declareIndependence");
assertNotNull(event); Event event = spec().getEvent("model.event.declareIndependence");
assertNotNull(event.getLimits()); assertNotNull(event);
assertNotNull(spec().getOption(GameOptions.LAST_COLONIAL_YEAR)); assertNotNull(event.getLimits());
assertNotNull(spec().getOption(GameOptions.LAST_COLONIAL_YEAR));
Limit rebelLimit = event.getLimit("model.limit.independence.rebels");
Limit colonyLimit = event.getLimit("model.limit.independence.coastalColonies"); Limit rebelLimit = event.getLimit("model.limit.independence.rebels");
Limit yearLimit = event.getLimit("model.limit.independence.year"); Limit colonyLimit = event
.getLimit("model.limit.independence.coastalColonies");
assertNotNull(rebelLimit); Limit yearLimit = event.getLimit("model.limit.independence.year");
assertEquals(Limit.Operator.GE, rebelLimit.getOperator());
assertEquals(Operand.OperandType.NONE, rebelLimit.getLeftHandSide().getOperandType()); assertNotNull(rebelLimit);
assertEquals(Operand.ScopeLevel.PLAYER, rebelLimit.getLeftHandSide().getScopeLevel()); assertEquals(Limit.Operator.GE, rebelLimit.getOperator());
assertEquals(Integer.valueOf(0), rebelLimit.getLeftHandSide().getValue(dutch)); assertEquals(Operand.OperandType.NONE, rebelLimit.getLeftHandSide()
assertEquals(Integer.valueOf(50), rebelLimit.getRightHandSide().getValue(dutch)); .getOperandType());
assertFalse(rebelLimit.evaluate(dutch)); assertEquals(Operand.ScopeLevel.PLAYER, rebelLimit.getLeftHandSide()
.getScopeLevel());
assertNotNull(colonyLimit); assertEquals(Integer.valueOf(0),
assertEquals(Limit.Operator.GE, colonyLimit.getOperator()); rebelLimit.getLeftHandSide().getValue(dutch));
assertEquals(Operand.OperandType.SETTLEMENTS, colonyLimit.getLeftHandSide().getOperandType()); assertEquals(Integer.valueOf(50), rebelLimit.getRightHandSide()
assertEquals(Operand.ScopeLevel.PLAYER, colonyLimit.getLeftHandSide().getScopeLevel()); .getValue(dutch));
assertEquals("isConnectedPort", colonyLimit.getLeftHandSide().getMethodName()); assertFalse(rebelLimit.evaluate(dutch));
assertFalse(colony.isConnectedPort());
assertEquals(Integer.valueOf(0), colonyLimit.getLeftHandSide().getValue(dutch)); assertNotNull(colonyLimit);
assertEquals(Integer.valueOf(1), colonyLimit.getRightHandSide().getValue(dutch)); assertEquals(Limit.Operator.GE, colonyLimit.getOperator());
assertFalse(colonyLimit.evaluate(dutch)); assertEquals(Operand.OperandType.SETTLEMENTS, colonyLimit
.getLeftHandSide().getOperandType());
assertNotNull(yearLimit); assertEquals(Operand.ScopeLevel.PLAYER, colonyLimit.getLeftHandSide()
assertEquals(Limit.Operator.LE, yearLimit.getOperator()); .getScopeLevel());
assertEquals(Operand.OperandType.YEAR, yearLimit.getLeftHandSide().getOperandType()); assertEquals("isConnectedPort", colonyLimit.getLeftHandSide()
assertEquals(Operand.OperandType.OPTION, yearLimit.getRightHandSide().getOperandType()); .getMethodName());
assertEquals(GameOptions.LAST_COLONIAL_YEAR, yearLimit.getRightHandSide().getType()); assertFalse(colony.isConnectedPort());
assertEquals(Integer.valueOf(1492), yearLimit.getLeftHandSide().getValue(dutch)); assertEquals(Integer.valueOf(0), colonyLimit.getLeftHandSide()
assertEquals(Integer.valueOf(1800), yearLimit.getRightHandSide().getValue(dutch)); .getValue(dutch));
assertTrue(yearLimit.evaluate(dutch)); assertEquals(Integer.valueOf(1), colonyLimit.getRightHandSide()
.getValue(dutch));
colony.modifyLiberty(10000); assertFalse(colonyLimit.evaluate(dutch));
colony.updateSoL();
assertTrue(rebelLimit.evaluate(dutch)); assertNotNull(yearLimit);
assertEquals(Limit.Operator.LE, yearLimit.getOperator());
Tile tile = colony.getTile().getNeighbourOrNull(Direction.N); assertEquals(Operand.OperandType.YEAR, yearLimit.getLeftHandSide()
tile.setType(spec().getTileType("model.tile.ocean")); .getOperandType());
tile.setHighSeasCount(5); assertEquals(Operand.OperandType.OPTION, yearLimit.getRightHandSide()
tile.setExplored(dutch, true); .getOperandType());
assertTrue(tile.isExploredBy(dutch)); assertEquals(GameOptions.LAST_COLONIAL_YEAR, yearLimit
assertTrue(tile.isHighSeasConnected()); .getRightHandSide().getType());
assertTrue(!tile.isLand()); assertEquals(Integer.valueOf(1492), yearLimit.getLeftHandSide()
assertTrue(colony.isConnectedPort()); .getValue(dutch));
assertTrue(colonyLimit.getLeftHandSide().appliesTo(colony)); assertEquals(Integer.valueOf(1800), yearLimit.getRightHandSide()
assertTrue(colonyLimit.evaluate(dutch)); .getValue(dutch));
assertTrue(yearLimit.evaluate(dutch));
IntegerOption option = spec()
.getIntegerOption(GameOptions.LAST_COLONIAL_YEAR); colony.modifyLiberty(10000);
option.setMinimumValue(1300); colony.updateSoL();
option.setValue(1300); assertTrue(rebelLimit.evaluate(dutch));
assertFalse(yearLimit.evaluate(dutch));
} Tile tile = colony.getTile().getNeighbourOrNull(Direction.N);
tile.setType(spec().getTileType("model.tile.ocean"));
public void testSuccessionLimits() { tile.setHighSeasCount(5);
tile.setExplored(dutch, true);
Game game = getStandardGame(); assertTrue(tile.isExploredBy(dutch));
Player dutch = game.getPlayerByNationId("model.nation.dutch"); assertTrue(tile.isHighSeasConnected());
Map map = getTestMap(); assertTrue(!tile.isLand());
game.setMap(map); assertTrue(colony.isConnectedPort());
assertTrue(colonyLimit.getLeftHandSide().appliesTo(colony));
Colony colony = getStandardColony(3); assertTrue(colonyLimit.evaluate(dutch));
Event event = spec().getEvent("model.event.spanishSuccession"); IntegerOption option = spec().getIntegerOption(
assertNotNull(event); GameOptions.LAST_COLONIAL_YEAR);
assertNotNull(event.getLimits()); option.setMinimumValue(1300);
option.setValue(1300);
Limit weakestPlayerLimit = event.getLimit("model.limit.spanishSuccession.weakestPlayer"); assertFalse(yearLimit.evaluate(dutch));
Limit strongestPlayerLimit = event.getLimit("model.limit.spanishSuccession.strongestPlayer");
Limit yearLimit = event.getLimit("model.limit.spanishSuccession.year"); }
assertNotNull(strongestPlayerLimit); @After
assertEquals(Limit.Operator.GT, strongestPlayerLimit.getOperator()); public void resetLastColonialYear() {
assertEquals(Operand.OperandType.NONE, strongestPlayerLimit.getLeftHandSide().getOperandType()); IntegerOption option = spec().getIntegerOption(
assertEquals(Operand.ScopeLevel.PLAYER, strongestPlayerLimit.getLeftHandSide().getScopeLevel()); GameOptions.LAST_COLONIAL_YEAR);
assertEquals(Integer.valueOf(0), strongestPlayerLimit.getLeftHandSide().getValue(dutch)); option.setMinimumValue(1800);
assertEquals(Integer.valueOf(50), strongestPlayerLimit.getRightHandSide().getValue(dutch)); option.setValue(1800);
assertFalse(strongestPlayerLimit.evaluate(dutch)); }
assertNotNull(weakestPlayerLimit); public void testSuccessionLimits() {
assertEquals(Limit.Operator.LT, weakestPlayerLimit.getOperator());
assertEquals(Operand.OperandType.NONE, weakestPlayerLimit.getLeftHandSide().getOperandType()); Game game = getStandardGame();
assertEquals(Operand.ScopeLevel.PLAYER, weakestPlayerLimit.getLeftHandSide().getScopeLevel()); Player dutch = game.getPlayerByNationId("model.nation.dutch");
assertEquals(Integer.valueOf(0), weakestPlayerLimit.getLeftHandSide().getValue(dutch)); Map map = getTestMap();
assertEquals(Integer.valueOf(50), weakestPlayerLimit.getRightHandSide().getValue(dutch)); game.setMap(map);
assertTrue(weakestPlayerLimit.evaluate(dutch));
Colony colony = getStandardColony(3);
assertNotNull(yearLimit);
assertEquals(Limit.Operator.GE, yearLimit.getOperator()); Event event = spec().getEvent("model.event.spanishSuccession");
assertEquals(Operand.OperandType.YEAR, yearLimit.getLeftHandSide().getOperandType()); assertNotNull(event);
assertEquals(Operand.ScopeLevel.GAME, yearLimit.getLeftHandSide().getScopeLevel()); assertNotNull(event.getLimits());
assertEquals(Integer.valueOf(1492), yearLimit.getLeftHandSide().getValue(game));
assertEquals(Integer.valueOf(1600), yearLimit.getRightHandSide().getValue()); Limit weakestPlayerLimit = event
assertFalse(yearLimit.evaluate(game)); .getLimit("model.limit.spanishSuccession.weakestPlayer");
Limit strongestPlayerLimit = event
colony.modifyLiberty(10000); .getLimit("model.limit.spanishSuccession.strongestPlayer");
colony.updateSoL(); Limit yearLimit = event.getLimit("model.limit.spanishSuccession.year");
assertTrue(strongestPlayerLimit.evaluate(dutch));
assertFalse(weakestPlayerLimit.evaluate(dutch)); assertNotNull(strongestPlayerLimit);
} assertEquals(Limit.Operator.GT, strongestPlayerLimit.getOperator());
assertEquals(Operand.OperandType.NONE, strongestPlayerLimit
.getLeftHandSide().getOperandType());
assertEquals(Operand.ScopeLevel.PLAYER, strongestPlayerLimit
.getLeftHandSide().getScopeLevel());
assertEquals(Integer.valueOf(0), strongestPlayerLimit.getLeftHandSide()
.getValue(dutch));
assertEquals(Integer.valueOf(50), strongestPlayerLimit
.getRightHandSide().getValue(dutch));
assertFalse(strongestPlayerLimit.evaluate(dutch));
assertNotNull(weakestPlayerLimit);
assertEquals(Limit.Operator.LT, weakestPlayerLimit.getOperator());
assertEquals(Operand.OperandType.NONE, weakestPlayerLimit
.getLeftHandSide().getOperandType());
assertEquals(Operand.ScopeLevel.PLAYER, weakestPlayerLimit
.getLeftHandSide().getScopeLevel());
assertEquals(Integer.valueOf(0), weakestPlayerLimit.getLeftHandSide()
.getValue(dutch));
assertEquals(Integer.valueOf(50), weakestPlayerLimit.getRightHandSide()
.getValue(dutch));
assertTrue(weakestPlayerLimit.evaluate(dutch));
assertNotNull(yearLimit);
assertEquals(Limit.Operator.GE, yearLimit.getOperator());
assertEquals(Operand.OperandType.YEAR, yearLimit.getLeftHandSide()
.getOperandType());
assertEquals(Operand.ScopeLevel.GAME, yearLimit.getLeftHandSide()
.getScopeLevel());
assertEquals(Integer.valueOf(1492), yearLimit.getLeftHandSide()
.getValue(game));
assertEquals(Integer.valueOf(1600), yearLimit.getRightHandSide()
.getValue());
assertFalse(yearLimit.evaluate(game));
colony.modifyLiberty(10000);
colony.updateSoL();
assertTrue(strongestPlayerLimit.evaluate(dutch));
assertFalse(weakestPlayerLimit.evaluate(dutch));
}
} }
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment