neocturne/JRummikub
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Wir haben noch einen classify-Bug gefunden... und behoben

Browse source 
git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@412 72836036-5685-4462-b002-a69064685172
This commit is contained in:
Ida Massow 2011-06-11 04:09:27 +02:00
parent acc1b64fe7
commit 8b1e09f025
2 changed files with 138 additions and 166 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
src/jrummikub/model/StoneSet.java
View file

@ -23,7 +23,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Create a new single stone stone set * Create a new single stone stone set
* *
* @param stone * @param stone
* single stone of the set * single stone of the set
*/ */
public StoneSet(Stone stone) { public StoneSet(Stone stone) {
stones = new ArrayList<Stone>(Collections.singletonList(stone)); stones = new ArrayList<Stone>(Collections.singletonList(stone));
@ -33,7 +33,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Create a stone set from a list of stones * Create a stone set from a list of stones
* *
* @param stones * @param stones
* list of stones to build a set of * list of stones to build a set of
*/ */
public StoneSet(List<Stone> stones) { public StoneSet(List<Stone> stones) {
this.stones = new ArrayList<Stone>(stones); this.stones = new ArrayList<Stone>(stones);
@ -53,7 +53,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Test for rule conflict within the StoneSet * Test for rule conflict within the StoneSet
* *
* @param settings * @param settings
* GameSettings * GameSettings
* *
* @return true when the set is valid according to the rules * @return true when the set is valid according to the rules
*/ */
@ -62,11 +62,11 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
} }
/** /**
* Test for rule conflict within the StoneSet and determine whether the set is * Test for rule conflict within the StoneSet and determine whether the set
* a group or a run * is a group or a run
* *
* @param settings * @param settings
* GameSettings * GameSettings
* *
* @return GROUP or RUN for valid sets, INVALID otherwise * @return GROUP or RUN for valid sets, INVALID otherwise
*/ */
@ -84,13 +84,18 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
} }
if (nonJoker == -1) { if (nonJoker == -1) {
if (stones.size() > settings.getHighestValue()) { if (stones.size() > settings.getHighestValue()
&& stones.size() > settings.getStoneColors().size()) {
return new Pair<Type, Integer>(INVALID, 0); return new Pair<Type, Integer>(INVALID, 0);
} else if (stones.size() > settings.getStoneColors().size()) { } else if (stones.size() > settings.getStoneColors().size()) {
return new Pair<Type, Integer>(RUN, return new Pair<Type, Integer>(
(settings.getHighestValue() * (settings.getHighestValue() + 1)) / 2 RUN,
(settings.getHighestValue() * (settings
.getHighestValue() + 1))
/ 2
- (stones.size() - settings.getHighestValue()) - (stones.size() - settings.getHighestValue())
* (stones.size() - settings.getHighestValue() - 1) / 2); * (stones.size() - settings.getHighestValue() - 1)
/ 2);
} else { } else {
return new Pair<Type, Integer>(GROUP, stones.size() return new Pair<Type, Integer>(GROUP, stones.size()
* settings.getHighestValue()); * settings.getHighestValue());
@ -113,7 +118,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Test for rule conflict within the StoneSet, assuming we have a run * Test for rule conflict within the StoneSet, assuming we have a run
* *
* @param referencePosition * @param referencePosition
* position of stone used as reference (any non-joker stone) * position of stone used as reference (any non-joker stone)
* @param settings * @param settings
*/ */
private int isValidRun(int referencePosition, GameSettings settings) { private int isValidRun(int referencePosition, GameSettings settings) {
@ -173,7 +178,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Stone Sets * Stone Sets
* *
* @param position * @param position
* Splitting {@link Position} * Splitting {@link Position}
* @return A pair of StoneSets, one for each split part * @return A pair of StoneSets, one for each split part
*/ */
public Pair<StoneSet, StoneSet> splitAt(int position) { public Pair<StoneSet, StoneSet> splitAt(int position) {
@ -183,7 +188,8 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
return new Pair<StoneSet, StoneSet>(this, null); return new Pair<StoneSet, StoneSet>(this, null);
} }
StoneSet firstSet = new StoneSet(stones.subList(0, position)); StoneSet firstSet = new StoneSet(stones.subList(0, position));
StoneSet secondSet = new StoneSet(stones.subList(position, stones.size())); StoneSet secondSet = new StoneSet(stones.subList(position,
stones.size()));
return new Pair<StoneSet, StoneSet>(firstSet, secondSet); return new Pair<StoneSet, StoneSet>(firstSet, secondSet);
} }
@ -191,7 +197,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Joins StoneSet to another StoneSet and returns the resulting new StoneSet * Joins StoneSet to another StoneSet and returns the resulting new StoneSet
* *
* @param other * @param other
* StoneSet to be joined to active StoneSet * StoneSet to be joined to active StoneSet
* @return the combined StoneSet * @return the combined StoneSet
*/ */
public StoneSet join(StoneSet other) { public StoneSet join(StoneSet other) {
@ -214,7 +220,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable, Serializable {
* Returns the i-th stone of the set (starting with 0) * Returns the i-th stone of the set (starting with 0)
* *
* @param i * @param i
* number of the stone to return * number of the stone to return
* @return the i-th stone * @return the i-th stone
*/ */
public Stone get(int i) { public Stone get(int i) {

268
test/jrummikub/model/StoneSetTest.java
View file

@ -26,6 +26,7 @@ public class StoneSetTest {
private GameSettings lowerValueSettings = new GameSettings(); private GameSettings lowerValueSettings = new GameSettings();
private GameSettings noLimitsSettings = new GameSettings(); private GameSettings noLimitsSettings = new GameSettings();
private GameSettings noLimitsLowerValueSettings = new GameSettings(); private GameSettings noLimitsLowerValueSettings = new GameSettings();
private GameSettings moreColorLowerValueSettings = new GameSettings();
/** */ /** */
@Before @Before
@ -38,6 +39,9 @@ public class StoneSetTest {
noLimitsSettings.setNoLimits(true); noLimitsSettings.setNoLimits(true);
noLimitsLowerValueSettings.setHighestValue(10); noLimitsLowerValueSettings.setHighestValue(10);
noLimitsLowerValueSettings.setNoLimits(true); noLimitsLowerValueSettings.setNoLimits(true);
moreColorLowerValueSettings.setStoneColors(EnumSet
.allOf(StoneColor.class));
moreColorLowerValueSettings.setHighestValue(5);
} }
private void assertSet(StoneSet.Type expectedType, Integer expectedValue, private void assertSet(StoneSet.Type expectedType, Integer expectedValue,
@ -53,29 +57,22 @@ public class StoneSetTest {
public void doubleJokerValid() { public void doubleJokerValid() {
// 3 Stones // 3 Stones
// JJZ // JJZ
assertSet(GROUP, 3, assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(BLACK),
Arrays.asList(new Stone(RED), new Stone(BLACK), new Stone(1, BLACK)), new Stone(1, BLACK)), defaultSettings);
defaultSettings);
// JZJ // JZJ
assertSet(GROUP, 3, assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
Arrays.asList(new Stone(RED), new Stone(1, BLACK), new Stone(BLACK)), new Stone(BLACK)), defaultSettings);
defaultSettings);
// ZJJ // ZJJ
assertSet(RUN, 6, assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
Arrays.asList(new Stone(1, RED), new Stone(RED), new Stone(BLACK)), new Stone(BLACK)), defaultSettings);
defaultSettings); assertSet(RUN, 33, Arrays.asList(new Stone(10, RED), new Stone(RED),
assertSet(RUN, 33, new Stone(BLACK)), defaultSettings);
Arrays.asList(new Stone(10, RED), new Stone(RED), new Stone(BLACK)), assertSet(GROUP, 30, Arrays.asList(new Stone(10, RED), new Stone(RED),
defaultSettings); new Stone(BLACK)), lowerValueSettings);
assertSet(GROUP, 30, assertSet(GROUP, 39, Arrays.asList(new Stone(13, RED), new Stone(RED),
Arrays.asList(new Stone(10, RED), new Stone(RED), new Stone(BLACK)), new Stone(BLACK)), defaultSettings);
lowerValueSettings); assertSet(RUN, 42, Arrays.asList(new Stone(13, RED), new Stone(RED),
assertSet(GROUP, 39, new Stone(BLACK)), higherValueSettings);
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 // 4 Stones
// JJZZ // JJZZ
assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(BLACK), assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(BLACK),
@ -85,8 +82,9 @@ public class StoneSetTest {
// ZZJJ // ZZJJ
assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(2, RED), assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
new Stone(BLACK), new Stone(RED)), defaultSettings); new Stone(BLACK), new Stone(RED)), defaultSettings);
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
new Stone(BLACK), new Stone(RED)), defaultSettings); new Stone(1, BLACK), new Stone(BLACK), new Stone(RED)),
defaultSettings);
// ZJZJ // ZJZJ
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK), assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
new Stone(1, BLACK), new Stone(RED)), defaultSettings); new Stone(1, BLACK), new Stone(RED)), defaultSettings);
@ -108,100 +106,81 @@ public class StoneSetTest {
assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED), assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
new Stone(BLACK), new Stone(4, RED)), defaultSettings); new Stone(BLACK), new Stone(4, RED)), defaultSettings);
// More than 4 stones // More than 4 stones
assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE), assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED),
new Stone(1, GREEN), new Stone(1, BLACK), new Stone(BLACK), new Stone( new Stone(1, BLUE), new Stone(1, GREEN), new Stone(1, BLACK),
RED)), moreColorSettings); new Stone(BLACK), new Stone(RED)), moreColorSettings);
} }
/** */ /** */
@Test @Test
public void groups() { public void groups() {
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
new Stone(1, BLUE)), defaultSettings); new Stone(1, BLACK), new Stone(1, BLUE)), defaultSettings);
assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
new Stone(1, BLUE)), lessColorSettings); new Stone(1, BLACK), new Stone(1, BLUE)), lessColorSettings);
assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
new Stone(1, BLUE), new Stone(1, ORANGE)), defaultSettings); new Stone(1, BLACK), new Stone(1, BLUE), new Stone(1, ORANGE)),
assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED), new Stone(1, GREEN), defaultSettings);
new Stone(1, GRAY), new Stone(1, BLACK), new Stone(1, BLUE), new Stone( assertSet(GROUP, 6, Arrays.asList(new Stone(1, RED),
1, ORANGE)), moreColorSettings); new Stone(1, GREEN), new Stone(1, GRAY), new Stone(1, BLACK),
new Stone(1, BLUE), new Stone(1, ORANGE)), moreColorSettings);
} }
/** */ /** */
@Test @Test
public void runs() { public void runs() {
assertSet(RUN, 6, assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
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)),
defaultSettings); defaultSettings);
assertSet(RUN, 6, assertSet(RUN, 42, Arrays.asList(new Stone(13, RED),
Arrays.asList(new Stone(1, RED), new Stone(2, RED), new Stone(3, RED)), new Stone(14, RED), new Stone(15, RED)), higherValueSettings);
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)), defaultSettings);
assertSet(RUN, 42, Arrays.asList(new Stone(13, RED), new Stone(14, RED),
new Stone(15, RED)), higherValueSettings);
} }
/** */ /** */
@Test @Test
public void singleJoker() { public void singleJoker() {
// ZJZ // ZJZ
assertSet( assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
GROUP, new Stone(1, BLACK)), defaultSettings);
3, assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
Arrays.asList(new Stone(1, RED), new Stone(BLACK), new Stone(1, BLACK)), new Stone(3, RED)), defaultSettings);
defaultSettings);
assertSet(RUN, 6,
Arrays.asList(new Stone(1, RED), new Stone(RED), new Stone(3, RED)),
defaultSettings);
// JZZ // JZZ
assertSet(GROUP, 3, assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, RED),
Arrays.asList(new Stone(RED), new Stone(1, RED), new Stone(1, BLACK)), new Stone(1, BLACK)), defaultSettings);
defaultSettings); assertSet(RUN, 6, Arrays.asList(new Stone(RED), new Stone(2, RED),
assertSet(RUN, 6, new Stone(3, RED)), defaultSettings);
Arrays.asList(new Stone(RED), new Stone(2, RED), new Stone(3, RED)),
defaultSettings);
// ZZJ // ZZJ
assertSet( assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
GROUP, new Stone(1, BLACK), new Stone(BLACK)), defaultSettings);
3, assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), new Stone(BLACK)), new Stone(RED)), defaultSettings);
defaultSettings); assertSet(RUN, 39, Arrays.asList(new Stone(12, RED),
assertSet(RUN, 6, new Stone(13, RED), new Stone(RED)), higherValueSettings);
Arrays.asList(new Stone(1, RED), new Stone(2, RED), new Stone(RED)),
defaultSettings);
assertSet(RUN, 39,
Arrays.asList(new Stone(12, RED), new Stone(13, RED), new Stone(RED)),
higherValueSettings);
} }
@Test @Test
public void noLimitsTest() { public void noLimitsTest() {
assertSet(RUN, 16, assertSet(RUN, 16, Arrays.asList(new Stone(RED), new Stone(1, RED),
Arrays.asList(new Stone(RED), new Stone(1, RED), new Stone(2, RED)), new Stone(2, RED)), noLimitsSettings);
noLimitsSettings); assertSet(RUN, 26, Arrays.asList(new Stone(12, RED),
assertSet(RUN, 26, new Stone(13, RED), new Stone(RED)), noLimitsSettings);
Arrays.asList(new Stone(12, RED), new Stone(13, RED), new Stone(RED)), assertSet(RUN, 20, Arrays.asList(new Stone(9, RED), new Stone(10, RED),
noLimitsSettings); new Stone(RED)), noLimitsLowerValueSettings);
assertSet(RUN, 20,
Arrays.asList(new Stone(9, RED), new Stone(10, RED), new Stone(RED)),
noLimitsLowerValueSettings);
assertSet(RUN, 28, Arrays.asList(new Stone(RED), new Stone(BLACK), assertSet(RUN, 28, Arrays.asList(new Stone(RED), new Stone(BLACK),
new Stone(1, RED), new Stone(2, RED)), noLimitsSettings); new Stone(1, RED), new Stone(2, RED)), noLimitsSettings);
assertSet(RUN, 26, Arrays.asList(new Stone(12, RED), new Stone(13, RED), assertSet(RUN, 26, Arrays.asList(new Stone(12, RED),
new Stone(1, RED)), noLimitsSettings); new Stone(13, RED), new Stone(1, RED)), noLimitsSettings);
assertSet( assertSet(RUN, 16, Arrays.asList(new Stone(13, RED), new Stone(1, RED),
RUN, new Stone(2, RED)), noLimitsSettings);
16,
Arrays.asList(new Stone(13, RED), new Stone(1, RED), new Stone(2, RED)),
noLimitsSettings);
assertSet(INVALID, 0, assertSet(INVALID, 0, Arrays.asList(new Stone(13, RED), new Stone(RED),
Arrays.asList(new Stone(13, RED), new Stone(RED), new Stone(1, RED)), new Stone(1, RED)), noLimitsSettings);
noLimitsSettings);
} }
// invalid // invalid
@ -211,87 +190,69 @@ public class StoneSetTest {
assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK), assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
new Stone(1, BLACK), new Stone(1, RED)), lessColorSettings); new Stone(1, BLACK), new Stone(1, RED)), lessColorSettings);
// More than 4 stones // More than 4 stones
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE), assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1, VIOLET), BLUE), new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1,
new Stone(1, ORANGE), new Stone(1, AQUA), new Stone(BLACK), new Stone( VIOLET), new Stone(1, ORANGE), new Stone(1, AQUA), new Stone(
RED)), moreColorSettings); BLACK), new Stone(RED)), moreColorSettings);
} }
/** */ /** */
@Test @Test
public void outOfBounds() { public void outOfBounds() {
assertSet(INVALID, 0, assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(1, RED),
Arrays.asList(new Stone(RED), new Stone(1, RED), new Stone(2, RED)), new Stone(2, RED)), defaultSettings);
defaultSettings); assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13,
assertSet(INVALID, 0, RED), new Stone(RED)), defaultSettings);
Arrays.asList(new Stone(12, RED), new Stone(13, RED), new Stone(RED)), assertSet(INVALID, 0, Arrays.asList(new Stone(9, RED), new Stone(10,
defaultSettings); RED), new Stone(RED)), lowerValueSettings);
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), assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
new Stone(1, RED), new Stone(2, RED)), defaultSettings); new Stone(1, RED), new Stone(2, RED)), defaultSettings);
assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13, RED), assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13,
new Stone(1, RED)), defaultSettings); RED), new Stone(1, RED)), defaultSettings);
assertSet( assertSet(INVALID, 0, Arrays.asList(new Stone(13, RED), new Stone(1,
INVALID, RED), new Stone(2, RED)), defaultSettings);
0,
Arrays.asList(new Stone(13, RED), new Stone(1, RED), new Stone(2, RED)),
defaultSettings);
} }
/** */ /** */
@Test @Test
public void sameColor() { public void sameColor() {
assertSet( assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED),
INVALID, new Stone(1, RED), new Stone(1, BLUE)), defaultSettings);
0, assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
Arrays.asList(new Stone(1, RED), new Stone(1, RED), new Stone(1, BLUE)), BLUE), new Stone(1, BLACK), new Stone(1, ORANGE),
defaultSettings); new Stone(RED)), defaultSettings);
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE), assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
new Stone(1, BLACK), new Stone(1, ORANGE), new Stone(RED)), BLUE), new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1,
defaultSettings); VIOLET), new Stone(1, GRAY), new Stone(1, ORANGE), new Stone(1,
assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE), AQUA), new Stone(RED)), moreColorSettings);
new Stone(1, GREEN), new Stone(1, BLACK), new Stone(1, VIOLET),
new Stone(1, GRAY), new Stone(1, ORANGE), new Stone(1, AQUA),
new Stone(RED)), moreColorSettings);
} }
/** */ /** */
@Test @Test
public void incorrectOrder() { public void incorrectOrder() {
assertSet(INVALID, 0, assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(5, RED)), new Stone(6, RED), new Stone(5, RED)), defaultSettings);
defaultSettings); assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
assertSet(INVALID, 0, new Stone(6, RED), new Stone(RED)), defaultSettings);
Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(RED)), assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(RED),
defaultSettings); new Stone(5, RED)), defaultSettings);
assertSet(INVALID, 0,
Arrays.asList(new Stone(4, RED), new Stone(RED), new Stone(5, RED)),
defaultSettings);
} }
/** */ /** */
@Test @Test
public void otherInvalid() { public void otherInvalid() {
assertSet(INVALID, 0, Arrays.asList(new Stone(4, 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)), defaultSettings);
assertSet(INVALID, 0, assertSet(INVALID, 0,
Arrays.asList(new Stone(4, RED), new Stone(5, RED), new Stone(7, RED)), Arrays.asList(new Stone(4, RED), new Stone(5, RED)),
defaultSettings);
assertSet(
INVALID,
0,
Arrays.asList(new Stone(4, RED), new Stone(5, BLUE), new Stone(6, RED)),
defaultSettings);
assertSet(INVALID, 0, 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)),
defaultSettings); defaultSettings);
assertSet(INVALID, 0, Arrays.asList(new Stone(4, BLUE), new Stone(5,
RED), new Stone(6, RED)), defaultSettings);
// Regression test: // Regression test:
assertSet(INVALID, 0, Arrays.asList(new Stone(12, ORANGE), new Stone(12, assertSet(INVALID, 0, Arrays.asList(new Stone(12, ORANGE), new Stone(
BLACK), new Stone(7, BLUE)), defaultSettings); 12, BLACK), new Stone(7, BLUE)), defaultSettings);
} }
/** */ /** */
@ -302,11 +263,16 @@ public class StoneSetTest {
defaultSettings); defaultSettings);
assertSet(GROUP, 4 * 13, Arrays.asList(new Stone(RED), new Stone(RED), assertSet(GROUP, 4 * 13, Arrays.asList(new Stone(RED), new Stone(RED),
new Stone(RED), new Stone(RED)), defaultSettings); new Stone(RED), new Stone(RED)), defaultSettings);
assertSet(RUN, 13 + 12 + 11 + 10 + 9, Arrays.asList(new Stone(RED), assertSet(RUN, 13 + 12 + 11 + 10 + 9,
new Stone(RED), new Stone(RED), new Stone(RED), new Stone(RED)), Arrays.asList(new Stone(RED), new Stone(RED), new Stone(RED),
defaultSettings); new Stone(RED), new Stone(RED)), defaultSettings);
assertSet(RUN, 5 * 10, Arrays.asList(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)), defaultSettings); new Stone(RED), new Stone(RED), new Stone(12, RED)),
defaultSettings);
assertSet(GROUP, 6 * 5,
Arrays.asList(new Stone(RED), new Stone(RED), new Stone(RED),
new Stone(RED), new Stone(RED), new Stone(AQUA)),
moreColorLowerValueSettings);
} }
/** */ /** */