Tests für Sets mit mehr Farben, mehr Values, ...
git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@332 72836036-5685-4462-b002-a69064685172
This commit is contained in:
Ida Massow
parent
d66d73ea8f
commit
f22ff5f0f1
12 changed files with 308 additions and 186 deletions
|
|
@ -78,7 +78,8 @@ public class RoundControl {
|
|||
}
|
||||
|
||||
private void prepareTurn() {
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings().getTurnControlType() == HUMAN;
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
||||
.getTurnControlType() == HUMAN;
|
||||
clonedTable = (ITable) roundState.getTable().clone();
|
||||
|
||||
if (isHuman) {
|
||||
|
|
@ -101,7 +102,8 @@ public class RoundControl {
|
|||
private void startTurn() {
|
||||
if (turnControl != null)
|
||||
return;
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings().getTurnControlType() == HUMAN;
|
||||
boolean isHuman = roundState.getActivePlayer().getPlayerSettings()
|
||||
.getTurnControlType() == HUMAN;
|
||||
boolean inspectOnly = roundState.getTurnNumber() < 1;
|
||||
boolean mayRedeal = inspectOnly
|
||||
&& roundState.getActivePlayer().getHand()
|
||||
|
|
@ -110,10 +112,11 @@ public class RoundControl {
|
|||
if (isHuman) {
|
||||
view.getPlayerPanel().setEndTurnMode(inspectOnly, mayRedeal);
|
||||
}
|
||||
turnControl = TurnControlFactory.getFactory(roundState.getActivePlayer()
|
||||
.getPlayerSettings().getTurnControlType()).create();
|
||||
turnControl.setup(roundState.getActivePlayer(), clonedTable,
|
||||
view, inspectOnly, mayRedeal);
|
||||
turnControl = TurnControlFactory.getFactory(
|
||||
roundState.getActivePlayer().getPlayerSettings()
|
||||
.getTurnControlType()).create();
|
||||
turnControl.setup(roundState.getActivePlayer(), clonedTable, view,
|
||||
inspectOnly, mayRedeal);
|
||||
turnControl.getEndOfTurnEvent().add(new IListener() {
|
||||
@Override
|
||||
public void handle() {
|
||||
|
|
@ -148,7 +151,8 @@ public class RoundControl {
|
|||
|
||||
int totalValue = 0;
|
||||
for (StoneSet set : newSets) {
|
||||
totalValue += set.classify().getSecond();
|
||||
totalValue += set.classify(roundState.getGameSettings())
|
||||
.getSecond();
|
||||
}
|
||||
|
||||
return totalValue == 0
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ public class RoundState implements IRoundState {
|
|||
public RoundState(GameSettings gameSettings) {
|
||||
this.gameSettings = gameSettings;
|
||||
|
||||
table = new Table();
|
||||
table = new Table(gameSettings);
|
||||
players = new ArrayList<Player>();
|
||||
|
||||
for (PlayerSettings playerSettings : gameSettings.getPlayerList()) {
|
||||
|
|
|
|||
|
|
@ -9,5 +9,13 @@ public enum StoneColor {
|
|||
/** */
|
||||
BLUE,
|
||||
/** */
|
||||
RED
|
||||
RED,
|
||||
/** */
|
||||
GREEN,
|
||||
/** */
|
||||
VIOLET,
|
||||
/** */
|
||||
BROWN,
|
||||
/** */
|
||||
WHITE
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ package jrummikub.model;
|
|||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.EnumSet;
|
||||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
|
|
@ -24,20 +23,24 @@ public class StoneHeap {
|
|||
* */
|
||||
public StoneHeap(GameSettings gameSettings) {
|
||||
heap = new ArrayList<Stone>();
|
||||
for (int i = 1; i <= 13; i++) {
|
||||
for (int i = 1; i <= gameSettings.getHighestCard(); i++) {
|
||||
for (int j = 0; j < gameSettings.getStoneSetNumber(); j++) {
|
||||
for (StoneColor c : EnumSet.allOf(StoneColor.class)) {
|
||||
for (StoneColor c : gameSettings.getStoneColors()) {
|
||||
heap.add(new Stone(i, c));
|
||||
}
|
||||
}
|
||||
}
|
||||
// Joker
|
||||
|
||||
ArrayList<StoneColor> jokerColors = new ArrayList<StoneColor>(Arrays.asList(StoneColor.values()));
|
||||
ArrayList<StoneColor> jokerColors = new ArrayList<StoneColor>(
|
||||
Arrays.asList(StoneColor.values()));
|
||||
jokerColors.retainAll(gameSettings.getStoneColors());
|
||||
|
||||
if (jokerColors.size() >= 4) {
|
||||
StoneColor temp = jokerColors.get(1);
|
||||
jokerColors.set(1, jokerColors.get(3));
|
||||
jokerColors.set(3, temp);
|
||||
}
|
||||
|
||||
int jokersLeft = gameSettings.getJokerNumber();
|
||||
done: while (true) {
|
||||
|
|
|
|||
|
|
@ -51,8 +51,8 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
|
|||
*
|
||||
* @return true when the set is valid according to the rules
|
||||
*/
|
||||
public boolean isValid() {
|
||||
return classify().getFirst() != INVALID;
|
||||
public boolean isValid(GameSettings settings) {
|
||||
return classify(settings).getFirst() != INVALID;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -62,7 +62,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
|
|||
* @return GROUP or RUN for valid sets, INVALID otherwise
|
||||
*/
|
||||
|
||||
public Pair<Type, Integer> classify() {
|
||||
public Pair<Type, Integer> classify(GameSettings settings) {
|
||||
if (stones.size() < 3) {
|
||||
return new Pair<Type, Integer>(INVALID, 0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import jrummikub.util.Pair;
|
|||
/** Class administering the {@link Stone}s on the game-Table */
|
||||
|
||||
public class Table extends StoneTray<StoneSet> implements ITable {
|
||||
private GameSettings gameSettings;
|
||||
|
||||
private static class StoneInfo {
|
||||
StoneSet set;
|
||||
|
|
@ -18,6 +19,10 @@ public class Table extends StoneTray<StoneSet> implements ITable {
|
|||
}
|
||||
}
|
||||
|
||||
public Table(GameSettings settings) {
|
||||
gameSettings = settings;
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes {@link Stone} from the Table
|
||||
*
|
||||
|
|
@ -69,21 +74,21 @@ public class Table extends StoneTray<StoneSet> implements ITable {
|
|||
return info.set;
|
||||
}
|
||||
|
||||
private void splitSet(StoneSet set, Position setPosition,
|
||||
int stonePosition) {
|
||||
private void splitSet(StoneSet set, Position setPosition, int stonePosition) {
|
||||
pickUp(set);
|
||||
|
||||
Pair<StoneSet, StoneSet> firstSplit = set.splitAt(stonePosition);
|
||||
Pair<StoneSet, StoneSet> secondSplit = firstSplit.getSecond().splitAt(1);
|
||||
Pair<StoneSet, StoneSet> secondSplit = firstSplit.getSecond()
|
||||
.splitAt(1);
|
||||
|
||||
StoneSet leftSet = firstSplit.getFirst();
|
||||
StoneSet rightSet = secondSplit.getSecond();
|
||||
|
||||
if (set.classify().getFirst() == StoneSet.Type.RUN) {
|
||||
if (set.classify(gameSettings).getFirst() == StoneSet.Type.RUN) {
|
||||
Position leftPosition, rightPosition;
|
||||
leftPosition = setPosition;
|
||||
rightPosition = new Position(setPosition.getX() + stonePosition + 1,
|
||||
setPosition.getY());
|
||||
rightPosition = new Position(
|
||||
setPosition.getX() + stonePosition + 1, setPosition.getY());
|
||||
|
||||
drop(leftSet, leftPosition);
|
||||
drop(rightSet, rightPosition);
|
||||
|
|
@ -105,7 +110,7 @@ public class Table extends StoneTray<StoneSet> implements ITable {
|
|||
@Override
|
||||
public boolean isValid() {
|
||||
for (Pair<StoneSet, Position> i : this) {
|
||||
if (!i.getFirst().isValid()) {
|
||||
if (!i.getFirst().isValid(gameSettings)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -60,7 +60,8 @@ class StonePainter {
|
|||
int g = (int) (color.getGreen() * BRIGHTER_SCALE);
|
||||
int b = (int) (color.getBlue() * BRIGHTER_SCALE);
|
||||
|
||||
return new Color(r > 255 ? 255 : r, g > 255 ? 255 : g, b > 255 ? 255 : b);
|
||||
return new Color(r > 255 ? 255 : r, g > 255 ? 255 : g, b > 255 ? 255
|
||||
: b);
|
||||
}
|
||||
|
||||
private static Color hover(Color color) {
|
||||
|
|
@ -68,7 +69,8 @@ class StonePainter {
|
|||
int g = (int) (color.getGreen() * HOVER_RATIO + 255 * (1 - HOVER_RATIO));
|
||||
int b = (int) (color.getBlue() * HOVER_RATIO + 255 * (1 - HOVER_RATIO));
|
||||
|
||||
return new Color(r > 255 ? 255 : r, g > 255 ? 255 : g, b > 255 ? 255 : b);
|
||||
return new Color(r > 255 ? 255 : r, g > 255 ? 255 : g, b > 255 ? 255
|
||||
: b);
|
||||
}
|
||||
|
||||
private static Color getColor(StoneColor color) {
|
||||
|
|
@ -81,6 +83,14 @@ class StonePainter {
|
|||
return new Color(1.0f, 0.4f, 0.0f);
|
||||
case RED:
|
||||
return new Color(0.9f, 0.0f, 0.25f);
|
||||
case BROWN:
|
||||
return new Color(0.5f, 0.25f, 0.0f);
|
||||
case GREEN:
|
||||
return new Color(0.0f, 0.75f, 0.0f);
|
||||
case VIOLET:
|
||||
return new Color(0.75f, 0.325f, 0.75f);
|
||||
case WHITE:
|
||||
return new Color(1.0f, 1.0f, 1.0f);
|
||||
}
|
||||
|
||||
return null;
|
||||
|
|
@ -178,11 +188,16 @@ class StonePainter {
|
|||
Color hoveredFg = hover(defaultFg);
|
||||
Color hoveredSelectedFg = hover(selectedFg);
|
||||
|
||||
defaultStones.put(color, prepaintColor(defaultFg, defaultBackground));
|
||||
selectedStones.put(color, prepaintColor(selectedFg, selectedBackground));
|
||||
hoveredStones.put(color, prepaintColor(hoveredFg, hoveredBackground));
|
||||
hoveredSelectedStones.put(color,
|
||||
prepaintColor(hoveredSelectedFg, hoveredSelectedBackground));
|
||||
defaultStones.put(color,
|
||||
prepaintColor(defaultFg, defaultBackground));
|
||||
selectedStones.put(color,
|
||||
prepaintColor(selectedFg, selectedBackground));
|
||||
hoveredStones.put(color,
|
||||
prepaintColor(hoveredFg, hoveredBackground));
|
||||
hoveredSelectedStones
|
||||
.put(color,
|
||||
prepaintColor(hoveredSelectedFg,
|
||||
hoveredSelectedBackground));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -194,7 +209,8 @@ class StonePainter {
|
|||
setScale(scale);
|
||||
}
|
||||
|
||||
private void paintStoneBackground(Graphics2D g, Rectangle r, Color background) {
|
||||
private void paintStoneBackground(Graphics2D g, Rectangle r,
|
||||
Color background) {
|
||||
// Paint background
|
||||
g.setColor(background);
|
||||
g.fillRect(r.x, r.y, r.width, r.height);
|
||||
|
|
@ -294,8 +310,9 @@ class StonePainter {
|
|||
pos + (fm.getAscent() - fm.getDescent()) / 2 + 1);
|
||||
}
|
||||
g.setColor(color);
|
||||
g.drawString(value, (int) (r.x + r.width / 2 - stringRect.getWidth() / 2),
|
||||
pos + (fm.getAscent() - fm.getDescent()) / 2);
|
||||
g.drawString(value,
|
||||
(int) (r.x + r.width / 2 - stringRect.getWidth() / 2), pos
|
||||
+ (fm.getAscent() - fm.getDescent()) / 2);
|
||||
}
|
||||
|
||||
private void paintCircle(Graphics2D g, Rectangle r, Color background) {
|
||||
|
|
@ -304,11 +321,12 @@ class StonePainter {
|
|||
|
||||
// Paint circle
|
||||
g.setColor(background.darker());
|
||||
g.drawArc(r.x + r.width / 2 - size / 2, pos - size / 2, size, size, 50, 170);
|
||||
g.drawArc(r.x + r.width / 2 - size / 2, pos - size / 2, size, size, 50,
|
||||
170);
|
||||
|
||||
g.setColor(brighter(background));
|
||||
g.drawArc((int) (r.x + r.width / 2 - size / 2), pos - size / 2, size, size,
|
||||
-130, 170);
|
||||
g.drawArc((int) (r.x + r.width / 2 - size / 2), pos - size / 2, size,
|
||||
size, -130, 170);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -350,8 +368,8 @@ class StonePainter {
|
|||
if (stone.isJoker()) {
|
||||
g.drawImage(stoneMap.get(stone.getColor()).get(0), x, y, null);
|
||||
} else {
|
||||
g.drawImage(stoneMap.get(stone.getColor()).get(stone.getValue()), x, y,
|
||||
null);
|
||||
g.drawImage(stoneMap.get(stone.getColor()).get(stone.getValue()),
|
||||
x, y, null);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -70,8 +70,10 @@ public class RoundControlTest {
|
|||
gameSettings.getPlayerList().add(new PlayerSettings("Ida", Color.RED));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Matthias", Color.YELLOW));
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(new PlayerSettings("Bennet", Color.BLACK));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Jannis", Color.GREEN));
|
||||
gameSettings.getPlayerList().add(
|
||||
new PlayerSettings("Bennet", Color.BLACK));
|
||||
roundState = new RoundState(gameSettings);
|
||||
roundControl = new RoundControl(roundState, view);
|
||||
}
|
||||
|
|
@ -81,7 +83,8 @@ public class RoundControlTest {
|
|||
- testRoundState.table.getSize(), testRoundState.getGameHeap()
|
||||
.getSize());
|
||||
for (int i = 0; i < testRoundState.getPlayerCount(); i++) {
|
||||
assertEquals(14, testRoundState.getNthNextPlayer(i).getHand().getSize());
|
||||
assertEquals(14, testRoundState.getNthNextPlayer(i).getHand()
|
||||
.getSize());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -142,8 +145,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
assertEquals(14 + 6, hand.getSize());
|
||||
}
|
||||
|
|
@ -163,8 +166,8 @@ public class RoundControlTest {
|
|||
assertFalse(roundState.getActivePlayer().getLaidOut());
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
assertEquals(14 + 1, hand.getSize());
|
||||
}
|
||||
|
|
@ -211,8 +214,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(0, roundState.getTable().getSize());
|
||||
assertEquals(14 + 9, hand.getSize());
|
||||
}
|
||||
|
|
@ -282,8 +285,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 6, hand.getSize());
|
||||
}
|
||||
|
|
@ -356,8 +359,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 7, hand.getSize());
|
||||
}
|
||||
|
|
@ -420,8 +423,8 @@ public class RoundControlTest {
|
|||
view.tablePanel.clickEvent.emit(new Position(0, 0));
|
||||
|
||||
view.playerPanel.endTurnEvent.emit();
|
||||
assertFalse(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
|
||||
.getLaidOut());
|
||||
assertFalse(roundState
|
||||
.getNthNextPlayer(roundState.getPlayerCount() - 1).getLaidOut());
|
||||
assertEquals(2, roundState.getTable().getSize());
|
||||
assertEquals(14 + 3, hand.getSize());
|
||||
}
|
||||
|
|
@ -679,12 +682,15 @@ public class RoundControlTest {
|
|||
Stone blueTwo = new Stone(2, BLUE);
|
||||
Stone blueThree = new Stone(3, BLUE);
|
||||
Stone blueFour = new Stone(4, BLUE);
|
||||
StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne, blackOne));
|
||||
StoneSet oldSet1 = new StoneSet(
|
||||
Arrays.asList(blueOne, redOne, blackOne));
|
||||
StoneSet oldSet2 = new StoneSet(blueTwo);
|
||||
oldTable.drop(oldSet1, new Position(0, 0));
|
||||
oldTable.drop(oldSet2, new Position(0, 0));
|
||||
StoneSet newSet1 = new StoneSet(Arrays.asList(blueOne, blueTwo, blueFour));
|
||||
StoneSet newSet2 = new StoneSet(Arrays.asList(redOne, blackOne, blueThree));
|
||||
StoneSet newSet1 = new StoneSet(Arrays.asList(blueOne, blueTwo,
|
||||
blueFour));
|
||||
StoneSet newSet2 = new StoneSet(Arrays.asList(redOne, blackOne,
|
||||
blueThree));
|
||||
newTable.drop(newSet1, new Position(0, 0));
|
||||
newTable.drop(newSet2, new Position(0, 0));
|
||||
|
||||
|
|
@ -701,7 +707,7 @@ public class RoundControlTest {
|
|||
/** */
|
||||
@Test
|
||||
public void testTableSetDifference() {
|
||||
ITable oldTable = new Table();
|
||||
ITable oldTable = new Table(gameSettings);
|
||||
Stone blueOne = new Stone(1, BLUE);
|
||||
Stone redOne = new Stone(1, RED);
|
||||
Stone blackOne = new Stone(1, BLACK);
|
||||
|
|
@ -709,14 +715,15 @@ public class RoundControlTest {
|
|||
Stone blueTwo = new Stone(2, BLUE);
|
||||
Stone blueThree = new Stone(3, BLUE);
|
||||
Stone blueFour = new Stone(4, BLUE);
|
||||
StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne, blackOne,
|
||||
orangeOne));
|
||||
StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blueThree, blueFour));
|
||||
StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
|
||||
blackOne, orangeOne));
|
||||
StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blueThree,
|
||||
blueFour));
|
||||
oldTable.drop(oldSet1, new Position(0, 0));
|
||||
oldTable.drop(oldSet2, new Position(0, 0));
|
||||
ITable newTable = (Table) oldTable.clone();
|
||||
List<StoneSet> newSets = RoundControl
|
||||
.tableSetDifference(oldTable, newTable);
|
||||
List<StoneSet> newSets = RoundControl.tableSetDifference(oldTable,
|
||||
newTable);
|
||||
List<StoneSet> vanishedSets = RoundControl.tableSetDifference(newTable,
|
||||
oldTable);
|
||||
|
||||
|
|
@ -724,8 +731,8 @@ public class RoundControlTest {
|
|||
assertTrue(vanishedSets.isEmpty());
|
||||
|
||||
newTable.pickUp(oldSet2);
|
||||
newTable.drop(oldSet2.join(new StoneSet(new Stone(5, BLUE))), new Position(
|
||||
0, 0));
|
||||
newTable.drop(oldSet2.join(new StoneSet(new Stone(5, BLUE))),
|
||||
new Position(0, 0));
|
||||
newSets = RoundControl.tableSetDifference(oldTable, newTable);
|
||||
vanishedSets = RoundControl.tableSetDifference(newTable, oldTable);
|
||||
|
||||
|
|
@ -737,7 +744,8 @@ public class RoundControlTest {
|
|||
Stone redTwo = new Stone(2, RED);
|
||||
Stone redThree = new Stone(3, RED);
|
||||
Stone redFour = new Stone(4, RED);
|
||||
StoneSet oldSet3 = new StoneSet(Arrays.asList(redTwo, redThree, redFour));
|
||||
StoneSet oldSet3 = new StoneSet(
|
||||
Arrays.asList(redTwo, redThree, redFour));
|
||||
ITable newTable2 = (Table) oldTable.clone();
|
||||
newTable2.drop(oldSet3, new Position(0, 0));
|
||||
newSets = RoundControl.tableSetDifference(oldTable, newTable2);
|
||||
|
|
@ -799,19 +807,20 @@ public class RoundControlTest {
|
|||
}
|
||||
|
||||
testRoundState.players.get(0).laidOut = true;
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(1).laidOut = true;
|
||||
testRoundState.players.get(1).hand.drop(new Stone(RED), new Position(0, 0));
|
||||
testRoundState.players.get(1).hand.drop(new Stone(RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).laidOut = false;
|
||||
testRoundState.players.get(2).hand.drop(new Stone(9, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(10, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(11, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(9, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(10, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(11, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(3).laidOut = true;
|
||||
|
||||
testRound.endOfRound();
|
||||
|
|
@ -845,19 +854,19 @@ public class RoundControlTest {
|
|||
}
|
||||
|
||||
testRoundState.players.get(0).laidOut = true;
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(1, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(0).hand.drop(new Stone(2, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(1).laidOut = true;
|
||||
testRoundState.players.get(1).hand.drop(new Stone(3, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(1).hand.drop(new Stone(3, RED),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(2).laidOut = true;
|
||||
testRoundState.players.get(2).hand.drop(new Stone(3, BLUE), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(2).hand.drop(new Stone(3, BLUE),
|
||||
new Position(0, 0));
|
||||
testRoundState.players.get(3).laidOut = false;
|
||||
testRoundState.players.get(3).hand.drop(new Stone(13, RED), new Position(0,
|
||||
0));
|
||||
testRoundState.players.get(3).hand.drop(new Stone(13, RED),
|
||||
new Position(0, 0));
|
||||
|
||||
testRound.endOfRound();
|
||||
assertTrue(roundEnded);
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import java.util.List;
|
|||
import java.util.Set;
|
||||
|
||||
import jrummikub.control.ITurnTimer;
|
||||
import jrummikub.control.turn.HumanTurnControl;
|
||||
import jrummikub.model.GameSettings;
|
||||
import jrummikub.model.IHand;
|
||||
import jrummikub.model.ITable;
|
||||
import jrummikub.model.MockHand;
|
||||
|
|
@ -45,6 +45,10 @@ public class TurnControlTest {
|
|||
StoneSet[] getSetArray() {
|
||||
return objects.keySet().toArray(new StoneSet[0]);
|
||||
}
|
||||
|
||||
AccessibleTable (){
|
||||
super (new GameSettings());
|
||||
}
|
||||
}
|
||||
|
||||
class MockTimer implements ITurnTimer {
|
||||
|
|
|
|||
|
|
@ -1,8 +1,8 @@
|
|||
package jrummikub.model;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNotNull;
|
||||
|
||||
import java.util.EnumSet;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
|
@ -20,8 +20,10 @@ import org.junit.runner.RunWith;
|
|||
@RunWith(Theories.class)
|
||||
public class StoneHeapTest {
|
||||
|
||||
private static Pair<GameSettings, StoneHeap> createHeap(GameSettings settings) {
|
||||
return new Pair<GameSettings, StoneHeap>(settings, new StoneHeap(settings));
|
||||
private static Pair<GameSettings, StoneHeap> createHeap(
|
||||
GameSettings settings) {
|
||||
return new Pair<GameSettings, StoneHeap>(settings, new StoneHeap(
|
||||
settings));
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -54,7 +56,8 @@ public class StoneHeapTest {
|
|||
private int calculateTotalNumberOfStones(GameSettings testSettings) {
|
||||
int totalStones = testSettings.getHighestCard()
|
||||
* testSettings.getStoneSetNumber()
|
||||
* testSettings.getStoneColors().size() + testSettings.getJokerNumber();
|
||||
* testSettings.getStoneColors().size()
|
||||
+ testSettings.getJokerNumber();
|
||||
return totalStones;
|
||||
}
|
||||
|
||||
|
|
@ -81,7 +84,7 @@ public class StoneHeapTest {
|
|||
int stonesOfAColor = data.getFirst().getHighestCard()
|
||||
* data.getFirst().getStoneSetNumber();
|
||||
Map<StoneColor, Integer> counters = new HashMap<StoneColor, Integer>();
|
||||
for (StoneColor c : EnumSet.allOf(StoneColor.class)) {
|
||||
for (StoneColor c : data.getFirst().getStoneColors()) {
|
||||
counters.put(c, 0);
|
||||
}
|
||||
for (Stone i : data.getSecond().heap) {
|
||||
|
|
@ -90,7 +93,7 @@ public class StoneHeapTest {
|
|||
int count = counters.get(i.getColor());
|
||||
counters.put(i.getColor(), count + 1);
|
||||
}
|
||||
for (StoneColor c : EnumSet.allOf(StoneColor.class)) {
|
||||
for (StoneColor c : data.getFirst().getStoneColors()) {
|
||||
assertEquals(stonesOfAColor, (long) counters.get(c));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,91 +1,136 @@
|
|||
package jrummikub.model;
|
||||
|
||||
import static jrummikub.model.StoneColor.*;
|
||||
import static jrummikub.model.StoneSet.Type.*;
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.EnumSet;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
|
||||
import jrummikub.util.Pair;
|
||||
import static jrummikub.model.StoneColor.*;
|
||||
import static jrummikub.model.StoneSet.Type.*;
|
||||
|
||||
import org.junit.*;
|
||||
import static org.junit.Assert.*;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
/**
|
||||
* Tests for {@link StoneSet}
|
||||
*/
|
||||
public class StoneSetTest {
|
||||
private GameSettings defaultSettings = new GameSettings();
|
||||
private GameSettings moreColorSettings = new GameSettings();
|
||||
private GameSettings lessColorSettings = new GameSettings();
|
||||
private GameSettings higherValueSettings = new GameSettings();
|
||||
private GameSettings lowerValueSettings = new GameSettings();
|
||||
|
||||
/** */
|
||||
@Before
|
||||
public void setUpSettings() {
|
||||
moreColorSettings.setStoneColors(EnumSet.allOf(StoneColor.class));
|
||||
lessColorSettings.setStoneColors(new HashSet<StoneColor>(Arrays.asList(
|
||||
StoneColor.BLUE, StoneColor.RED, StoneColor.BLACK)));
|
||||
higherValueSettings.setHighestCard(17);
|
||||
lowerValueSettings.setHighestCard(10);
|
||||
}
|
||||
|
||||
private void assertSet(StoneSet.Type expectedType, Integer expectedValue,
|
||||
List<Stone> stones) {
|
||||
List<Stone> stones, GameSettings settings) {
|
||||
StoneSet set = new StoneSet(stones);
|
||||
assertSame(expectedType, set.classify().getFirst());
|
||||
assertEquals(expectedValue, set.classify().getSecond());
|
||||
assertSame(expectedType, set.classify(settings).getFirst());
|
||||
assertEquals(expectedValue, set.classify(settings).getSecond());
|
||||
}
|
||||
|
||||
// valid+point count
|
||||
/** */
|
||||
@Test
|
||||
public void doubleJoker() {
|
||||
public void doubleJokerValid() {
|
||||
// 3 Stones
|
||||
// JJZ
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(BLACK),
|
||||
new Stone(1, BLACK)));
|
||||
new Stone(1, BLACK)), defaultSettings);
|
||||
// JZJ
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
|
||||
new Stone(BLACK)));
|
||||
new Stone(BLACK)), defaultSettings);
|
||||
// ZJJ
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
|
||||
new Stone(BLACK)));
|
||||
new Stone(BLACK)), defaultSettings);
|
||||
assertSet(RUN, 33, Arrays.asList(new Stone(10, RED), new Stone(RED),
|
||||
new Stone(BLACK)), defaultSettings);
|
||||
assertSet(GROUP, 30, Arrays.asList(new Stone(10, RED), new Stone(RED),
|
||||
new Stone(BLACK)), lowerValueSettings);
|
||||
assertSet(GROUP, 39, Arrays.asList(new Stone(13, RED), new Stone(RED),
|
||||
new Stone(BLACK)), defaultSettings);
|
||||
assertSet(RUN, 42, Arrays.asList(new Stone(13, RED), new Stone(RED),
|
||||
new Stone(BLACK)), higherValueSettings);
|
||||
// 4 Stones
|
||||
// JJZZ
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(BLACK),
|
||||
new Stone(1, BLACK), new Stone(1, RED)));
|
||||
new Stone(1, BLACK), new Stone(1, RED)), defaultSettings);
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(BLACK),
|
||||
new Stone(3, RED), new Stone(4, RED)));
|
||||
new Stone(3, RED), new Stone(4, RED)), defaultSettings);
|
||||
// ZZJJ
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
|
||||
new Stone(BLACK), new Stone(RED)));
|
||||
new Stone(BLACK), new Stone(RED)), defaultSettings);
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLACK), new Stone(BLACK), new Stone(RED)));
|
||||
new Stone(1, BLACK), new Stone(BLACK), new Stone(RED)),
|
||||
defaultSettings);
|
||||
// ZJZJ
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
|
||||
new Stone(1, BLACK), new Stone(RED)));
|
||||
new Stone(1, BLACK), new Stone(RED)), defaultSettings);
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
|
||||
new Stone(3, RED), new Stone(BLACK)));
|
||||
new Stone(3, RED), new Stone(BLACK)), defaultSettings);
|
||||
// JZJZ
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
|
||||
new Stone(BLACK), new Stone(1, RED)));
|
||||
new Stone(BLACK), new Stone(1, RED)), defaultSettings);
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
|
||||
new Stone(BLACK), new Stone(4, RED)));
|
||||
new Stone(BLACK), new Stone(4, RED)), defaultSettings);
|
||||
// JZZJ
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
|
||||
new Stone(1, RED), new Stone(BLACK)));
|
||||
new Stone(1, RED), new Stone(BLACK)), defaultSettings);
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
|
||||
new Stone(3, RED), new Stone(BLACK)));
|
||||
new Stone(3, RED), new Stone(BLACK)), defaultSettings);
|
||||
// ZJJZ
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
|
||||
new Stone(RED), new Stone(1, BLACK)));
|
||||
new Stone(RED), new Stone(1, BLACK)), defaultSettings);
|
||||
assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
|
||||
new Stone(BLACK), new Stone(4, RED)));
|
||||
new Stone(BLACK), new Stone(4, RED)), defaultSettings);
|
||||
// More than 4 stones
|
||||
assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLUE), new Stone(1, GREEN), new Stone(1, BLACK),
|
||||
new Stone(BLACK), new Stone(RED)), moreColorSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void groups() {
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLACK), new Stone(1, BLUE)));
|
||||
new Stone(1, BLACK), new Stone(1, BLUE)), defaultSettings);
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLACK), new Stone(1, BLUE)), lessColorSettings);
|
||||
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLACK), new Stone(1, BLUE), new Stone(1, ORANGE)));
|
||||
new Stone(1, BLACK), new Stone(1, BLUE), new Stone(1, ORANGE)),
|
||||
defaultSettings);
|
||||
assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, GREEN), new Stone(1, WHITE), new Stone(1, BLACK),
|
||||
new Stone(1, BLUE), new Stone(1, ORANGE)), moreColorSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void runs() {
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
|
||||
new Stone(3, RED)));
|
||||
new Stone(3, RED)), defaultSettings);
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
|
||||
new Stone(3, RED)), lowerValueSettings);
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
|
||||
new Stone(3, RED)), higherValueSettings);
|
||||
assertSet(RUN, 22, Arrays.asList(new Stone(4, BLUE),
|
||||
new Stone(5, BLUE), new Stone(6, BLUE), new Stone(7, BLUE)));
|
||||
new Stone(5, BLUE), new Stone(6, BLUE), new Stone(7, BLUE)),
|
||||
defaultSettings);
|
||||
assertSet(RUN, 42, Arrays.asList(new Stone(13, RED),
|
||||
new Stone(14, RED), new Stone(15, RED)), higherValueSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
|
|
@ -93,82 +138,105 @@ public class StoneSetTest {
|
|||
public void singleJoker() {
|
||||
// ZJZ
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
|
||||
new Stone(1, BLACK)));
|
||||
new Stone(1, BLACK)), defaultSettings);
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
|
||||
new Stone(3, RED)));
|
||||
new Stone(3, RED)), defaultSettings);
|
||||
// JZZ
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, RED),
|
||||
new Stone(1, BLACK)));
|
||||
new Stone(1, BLACK)), defaultSettings);
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(RED), new Stone(2, RED),
|
||||
new Stone(3, RED)));
|
||||
new Stone(3, RED)), defaultSettings);
|
||||
// ZZJ
|
||||
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, BLACK), new Stone(BLACK)));
|
||||
new Stone(1, BLACK), new Stone(BLACK)), defaultSettings);
|
||||
assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
|
||||
new Stone(RED)));
|
||||
new Stone(RED)), defaultSettings);
|
||||
assertSet(RUN, 39, Arrays.asList(new Stone(12, RED),
|
||||
new Stone(13, RED), new Stone(RED)), higherValueSettings);
|
||||
}
|
||||
|
||||
// invalid
|
||||
/** */
|
||||
@Test
|
||||
public void doubleJokerInvalid() {
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
|
||||
new Stone(1, BLACK), new Stone(1, RED)), lessColorSettings);
|
||||
// More than 4 stones
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
|
||||
BLUE), new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1,
|
||||
VIOLET), new Stone(1, ORANGE), new Stone(1, BROWN), new Stone(
|
||||
BLACK), new Stone(RED)), moreColorSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void outOfBounds() {
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(1, RED),
|
||||
new Stone(2, RED)));
|
||||
new Stone(2, RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13,
|
||||
RED), new Stone(RED)));
|
||||
RED), new Stone(RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(9, RED), new Stone(10,
|
||||
RED), new Stone(RED)), lowerValueSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
|
||||
new Stone(1, RED), new Stone(2, RED)));
|
||||
new Stone(1, RED), new Stone(2, RED)), defaultSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void sameColor() {
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED),
|
||||
new Stone(1, RED), new Stone(1, BLUE)));
|
||||
new Stone(1, RED), new Stone(1, BLUE)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
|
||||
BLUE), new Stone(1, BLACK), new Stone(1, ORANGE),
|
||||
new Stone(RED)));
|
||||
new Stone(RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
|
||||
BLUE), new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1,
|
||||
VIOLET), new Stone(1, WHITE), new Stone(1, ORANGE), new Stone(
|
||||
1, BROWN), new Stone(RED)), moreColorSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void incorrectOrder() {
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
|
||||
new Stone(6, RED), new Stone(5, RED)));
|
||||
new Stone(6, RED), new Stone(5, RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
|
||||
new Stone(6, RED), new Stone(RED)));
|
||||
new Stone(6, RED), new Stone(RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(RED),
|
||||
new Stone(5, RED)));
|
||||
new Stone(5, RED)), defaultSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void otherInvalid() {
|
||||
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
|
||||
new Stone(5, RED), new Stone(7, RED)));
|
||||
new Stone(5, RED), new Stone(7, RED)), defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(5,
|
||||
BLUE), new Stone(6, RED)));
|
||||
BLUE), new Stone(6, RED)), defaultSettings);
|
||||
assertSet(INVALID, 0,
|
||||
Arrays.asList(new Stone(4, RED), new Stone(5, RED)));
|
||||
Arrays.asList(new Stone(4, RED), new Stone(5, RED)),
|
||||
defaultSettings);
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(4, BLUE), new Stone(5,
|
||||
RED), new Stone(6, RED)));
|
||||
RED), new Stone(6, RED)), defaultSettings);
|
||||
// Regression test:
|
||||
assertSet(INVALID, 0, Arrays.asList(new Stone(12, ORANGE), new Stone(
|
||||
12, BLACK), new Stone(7, BLUE)));
|
||||
12, BLACK), new Stone(7, BLUE)), defaultSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
@Test
|
||||
public void manyJokersValid() {
|
||||
assertSet(GROUP, 3 * 13, Arrays.asList(new Stone(RED),
|
||||
new Stone(RED), new Stone(RED)));
|
||||
assertSet(GROUP, 4 * 13, Arrays.asList(new Stone(RED),
|
||||
new Stone(RED), new Stone(RED), new Stone(RED)));
|
||||
assertSet(RUN, 13 + 12 + 11 + 10 + 9, Arrays.asList(new Stone(RED),
|
||||
new Stone(RED), new Stone(RED), new Stone(RED), new Stone(RED)));
|
||||
assertSet(RUN, 5 * 10, Arrays.asList(new Stone(RED),
|
||||
new Stone(RED), new Stone(RED), new Stone(RED), new Stone(12, RED)));
|
||||
assertSet(GROUP, 3 * 13,
|
||||
Arrays.asList(new Stone(RED), new Stone(RED), new Stone(RED)),
|
||||
defaultSettings);
|
||||
assertSet(GROUP, 4 * 13, Arrays.asList(new Stone(RED), new Stone(RED),
|
||||
new Stone(RED), new Stone(RED)), defaultSettings);
|
||||
assertSet(RUN, 13 + 12 + 11 + 10 + 9,
|
||||
Arrays.asList(new Stone(RED), new Stone(RED), new Stone(RED),
|
||||
new Stone(RED), new Stone(RED)), defaultSettings);
|
||||
assertSet(RUN, 5 * 10, Arrays.asList(new Stone(RED), new Stone(RED),
|
||||
new Stone(RED), new Stone(RED), new Stone(12, RED)),
|
||||
defaultSettings);
|
||||
}
|
||||
|
||||
/** */
|
||||
|
|
@ -178,7 +246,7 @@ public class StoneSetTest {
|
|||
for (int i = 0; i < 14; i++) {
|
||||
stones.add(new Stone(RED));
|
||||
}
|
||||
assertSet(INVALID, 0, stones);
|
||||
assertSet(INVALID, 0, stones, defaultSettings);
|
||||
}
|
||||
|
||||
// invalid Split
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ public class TableTest {
|
|||
/** */
|
||||
@Before
|
||||
public void setup() {
|
||||
testTable = new Table();
|
||||
testTable = new Table(new GameSettings());
|
||||
}
|
||||
|
||||
/** */
|
||||
|
|
|
|||
Reference in a new issue