Tests und imlementierung für Wert von Sets bestimmen, fertig und getestet

git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@242 72836036-5685-4462-b002-a69064685172

5 files changed, 147 insertions, 58 deletions

diff --git a/src/jrummikub/model/StoneSet.java b/src/jrummikub/model/StoneSet.java
index b798ad0..2fd8e96 100644
--- a/src/jrummikub/model/StoneSet.java
+++ b/src/jrummikub/model/StoneSet.java
@@ -52,7 +52,7 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 	 * @return true when the set is valid according to the rules
 	 */
 	public boolean isValid() {
-		return classify() != INVALID;
+		return classify().getFirst() != INVALID;
 	}
 
 	/**
@@ -61,10 +61,11 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 	 * 
 	 * @return GROUP or RUN for valid sets, INVALID otherwise
 	 */
-	public Type classify() {
+	// TODO: Vernünftige Werte Returnen
+	public Pair<Type, Integer> classify() {
 		// TODO: extend this for score calculation (release 2...)
 		if (stones.size() < 3) {
-			return INVALID;
+			return new Pair<Type, Integer>(INVALID, 0);
 		}
 		int nonJoker1 = -1, nonJoker2 = -1;
 		for (int i = 0; i < stones.size(); i++) {
@@ -75,18 +76,36 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 			nonJoker1 = i;
 		}
 		if (nonJoker2 == -1) {
-			return GROUP;
+			// Z first
+			if (nonJoker1 == 0 && stones.get(nonJoker1).getValue() < 12) {
+				int origValue = stones.get(nonJoker1).getValue();
+				int value = 0;
+				for (int i = 0; i < stones.size(); i++) {
+					value += origValue + i;
+				}
+				return new Pair<Type, Integer>(RUN, value);
+			} else {
+				int value = stones.get(nonJoker1).getValue() * stones.size();
+				return new Pair<Type, Integer>(GROUP, value);
+			}
 		}
+
 		// is run
 		if (stones.get(nonJoker1).getColor() == stones.get(nonJoker2)
 				.getColor()) {
-			return isValidRun(nonJoker1) ? RUN : INVALID;
+			if (isValidRun(nonJoker1) > 0) {
+				return new Pair<Type, Integer>(RUN, isValidRun(nonJoker1));
+			}
+			return new Pair<Type, Integer>(INVALID, 0);
 
 		}
 		// is group
 		else {
-			return isValidGroup(stones.get(nonJoker1).getValue()) ? GROUP
-					: INVALID;
+			if (isValidGroup(stones.get(nonJoker1).getValue()) > 0) {
+				return new Pair<Type, Integer>(GROUP, isValidGroup(stones.get(
+						nonJoker1).getValue()));
+			}
+			return new Pair<Type, Integer>(INVALID, 0);
 		}
 	}
 
@@ -96,13 +115,13 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 	 * @param referencePosition
 	 *            position of stone used as reference (any non-joker stone)
 	 */
-	private boolean isValidRun(int referencePosition) {
+	private int isValidRun(int referencePosition) {
 		StoneColor runColor = stones.get(referencePosition).getColor();
 		int startValue = stones.get(referencePosition).getValue()
 				- referencePosition;
 		int endValue = startValue + stones.size() - 1;
 		if (startValue < 1 || endValue > 13) {
-			return false;
+			return 0;
 		}
 		for (int i = 0; i < stones.size(); i++) {
 			if (stones.get(i).isJoker()) {
@@ -110,21 +129,25 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 			}
 			if (stones.get(i).getColor() != runColor) {
 				// warum macht er das nicht?
-				return false;
+				return 0;
 			}
 			if (stones.get(i).getValue() != i + startValue) {
-				return false;
+				return 0;
 			}
 		}
-		return true;
+		int value = 0;
+		for (int i = 0; i < stones.size(); i++) {
+			value += startValue + i;
+		}
+		return value;
 	}
 
 	/**
 	 * Test for rule conflict within the StoneSet, assuming we have a group
 	 */
-	private boolean isValidGroup(int value) {
+	private int isValidGroup(int value) {
 		if (stones.size() > 4) {
-			return false;
+			return 0;
 		}
 		Set<StoneColor> seenColors = new HashSet<StoneColor>();
 		for (Stone i : stones) {
@@ -132,15 +155,15 @@ public class StoneSet implements Iterable<Stone>, Sizeable {
 				continue;
 			}
 			if (i.getValue() != value) {
-				return false;
+				return 0;
 			}
 			if (seenColors.contains(i.getColor())) {
-				return false;
+				return 0;
 			} else {
 				seenColors.add(i.getColor());
 			}
 		}
-		return true;
+		return value * stones.size();
 	}
 
 	/**
diff --git a/src/jrummikub/model/Table.java b/src/jrummikub/model/Table.java
index f134975..a3e25eb 100644
--- a/src/jrummikub/model/Table.java
+++ b/src/jrummikub/model/Table.java
@@ -79,7 +79,7 @@ public class Table extends StoneTray<StoneSet> implements ITable {
 		StoneSet leftSet = firstSplit.getFirst();
 		StoneSet rightSet = secondSplit.getSecond();
 
-		if (set.classify() == StoneSet.Type.RUN) {
+		if (set.classify().getFirst() == StoneSet.Type.RUN) {
 			Position leftPosition, rightPosition;
 			leftPosition = setPosition;
 			rightPosition = new Position(setPosition.getX() + stonePosition + 1,
diff --git a/test/jrummikub/control/RoundControlTest.java b/test/jrummikub/control/RoundControlTest.java
index 6c8dffe..3e610e3 100644
--- a/test/jrummikub/control/RoundControlTest.java
+++ b/test/jrummikub/control/RoundControlTest.java
@@ -91,6 +91,17 @@ public class RoundControlTest {
 		view.getTablePanel().rightPlayerName = null;
 		view.displayStartTurnPanel = false;
 	}
+	
+	/** */
+	@Test 
+	public void playerCameOutCorrectly(){
+		MockTable oldTable = new MockTable();
+		MockTable newTable = new MockTable();
+		Stone blueTen = new Stone(10, BLUE);
+		Stone redTen = new Stone(10, RED);
+		Stone blackTen = new Stone(10, BLACK);
+		
+	}
 
 	/** */
 	@Test
diff --git a/test/jrummikub/model/GameStateTest.java b/test/jrummikub/model/GameStateTest.java
index 5681904..5a55aef 100644
--- a/test/jrummikub/model/GameStateTest.java
+++ b/test/jrummikub/model/GameStateTest.java
@@ -31,4 +31,5 @@ public class GameStateTest {
 		testGame.nextPlayer();
 		assertSame(Color.red, testGame.getActivePlayer().getColor());
 	}
+	
 }
diff --git a/test/jrummikub/model/StoneSetTest.java b/test/jrummikub/model/StoneSetTest.java
index e2962d4..4b83c94 100644
--- a/test/jrummikub/model/StoneSetTest.java
+++ b/test/jrummikub/model/StoneSetTest.java
@@ -16,92 +16,146 @@ import static org.junit.Assert.*;
  */
 public class StoneSetTest {
 
-	private void assertSet(StoneSet.Type expectedType, List<Stone> stones) {
+	private void assertSet(StoneSet.Type expectedType, Integer expectedValue,
+			List<Stone> stones) {
 		StoneSet set = new StoneSet(stones);
-		assertSame(expectedType, set.classify());
+		assertSame(expectedType, set.classify().getFirst());
+		assertEquals(expectedValue, set.classify().getSecond());
 	}
 
-	// valid
+	// valid+point count
 	/** */
 	@Test
 	public void doubleJoker() {
-		assertSet(GROUP,
-				Arrays.asList(new Stone(RED), new Stone(BLACK), new Stone(1, BLACK)));
+		// 3 Stones
+		// JJZ
+		assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(BLACK),
+				new Stone(1, BLACK)));
+		// JZJ
+		assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+				new Stone(BLACK)));
+		// ZJJ
+		assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
+				new Stone(BLACK)));
+		// 4 Stones
+		// JJZZ
+		assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(BLACK),
+				new Stone(1, BLACK), new Stone(1, RED)));
+		assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(BLACK),
+				new Stone(3, RED), new Stone(4, RED)));
+		// ZZJJ
+		assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+				new Stone(BLACK), new Stone(RED)));
+		assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
+				new Stone(1, BLACK), new Stone(BLACK), new Stone(RED)));
+		// ZJZJ
+		assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+				new Stone(1, BLACK), new Stone(RED)));
+		assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
+				new Stone(3, RED), new Stone(BLACK)));
+		// JZJZ
+		assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+				new Stone(BLACK), new Stone(1, RED)));
+		assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
+				new Stone(BLACK), new Stone(4, RED)));
+		// JZZJ
+		assertSet(GROUP, 4, Arrays.asList(new Stone(RED), new Stone(1, BLACK),
+				new Stone(1, RED), new Stone(BLACK)));
+		assertSet(RUN, 10, Arrays.asList(new Stone(RED), new Stone(2, RED),
+				new Stone(3, RED), new Stone(BLACK)));
+		// ZJJZ
+		assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+				new Stone(RED), new Stone(1, BLACK)));
+		assertSet(RUN, 10, Arrays.asList(new Stone(1, RED), new Stone(RED),
+				new Stone(BLACK), new Stone(4, RED)));
 	}
 
 	/** */
 	@Test
 	public void groups() {
-		assertSet(GROUP, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK),
-				new Stone(1, BLUE)));
-		assertSet(GROUP, Arrays.asList(new Stone(1, RED), new Stone(1, BLACK),
-				new Stone(1, BLUE), new Stone(1, ORANGE)));
+		assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
+				new Stone(1, BLACK), new Stone(1, BLUE)));
+		assertSet(GROUP, 4, Arrays.asList(new Stone(1, RED),
+				new Stone(1, BLACK), new Stone(1, BLUE), new Stone(1, ORANGE)));
 	}
 
 	/** */
 	@Test
 	public void runs() {
-		assertSet(RUN,
-				Arrays.asList(new Stone(1, RED), new Stone(2, RED), new Stone(3, RED)));
-		assertSet(RUN, Arrays.asList(new Stone(4, BLUE), new Stone(5, BLUE),
-				new Stone(6, BLUE)));
+		assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+				new Stone(3, RED)));
+		assertSet(RUN, 22, Arrays.asList(new Stone(4, BLUE), new Stone(5, BLUE),
+				new Stone(6, BLUE), new Stone(7, BLUE)));
 	}
 
 	/** */
 	@Test
 	public void singleJoker() {
-		assertSet(GROUP,
-				Arrays.asList(new Stone(1, RED), new Stone(1, BLACK), new Stone(RED)));
-		assertSet(RUN,
-				Arrays.asList(new Stone(2, RED), new Stone(3, RED), new Stone(BLACK)));
+		// ZJZ
+		assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED), new Stone(BLACK),
+				new Stone(1, BLACK)));
+		assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(RED),
+				new Stone(3, RED)));
+		// JZZ
+		assertSet(GROUP, 3, Arrays.asList(new Stone(RED), new Stone(1, RED),
+				new Stone(1, BLACK)));
+		assertSet(RUN, 6, Arrays.asList(new Stone(RED), new Stone(2, RED),
+				new Stone(3, RED)));
+		// ZZJ
+		assertSet(GROUP, 3, Arrays.asList(new Stone(1, RED),
+				new Stone(1, BLACK), new Stone(BLACK)));
+		assertSet(RUN, 6, Arrays.asList(new Stone(1, RED), new Stone(2, RED),
+				new Stone(RED)));
 	}
 
 	// invalid
 	/** */
 	@Test
 	public void outOfBounds() {
-		assertSet(INVALID, Arrays.asList(new Stone(RED), new Stone(1, RED),
+		assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(1, RED),
 				new Stone(2, RED)));
-		assertSet(INVALID, Arrays.asList(new Stone(12, RED),
-				new Stone(13, RED), new Stone(RED)));
-		assertSet(INVALID, Arrays.asList(new Stone(RED), new Stone(BLACK),
+		assertSet(INVALID, 0, Arrays.asList(new Stone(12, RED), new Stone(13,
+				RED), new Stone(RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(RED), new Stone(BLACK),
 				new Stone(1, RED), new Stone(2, RED)));
 	}
 
 	/** */
 	@Test
 	public void sameColor() {
-		assertSet(INVALID,
-				Arrays.asList(new Stone(1, RED), new Stone(1, RED), new Stone(1, BLUE)));
-		assertSet(INVALID, Arrays.asList(new Stone(1, RED), new Stone(1, BLUE),
-				new Stone(1, BLACK), new Stone(1, ORANGE), new Stone(RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED),
+				new Stone(1, RED), new Stone(1, BLUE)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(1, RED), new Stone(1,
+				BLUE), new Stone(1, BLACK), new Stone(1, ORANGE),
+				new Stone(RED)));
 	}
 
 	/** */
 	@Test
 	public void incorrectOrder() {
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(5, RED)));
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, RED), new Stone(6, RED), new Stone(RED)));
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, RED), new Stone(RED), new Stone(5, RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
+				new Stone(6, RED), new Stone(5, RED)));
+		assertSet(INVALID, 0, 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),
+				new Stone(5, RED)));
 	}
 
 	/** */
 	@Test
 	public void otherInvalid() {
 
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, RED), new Stone(5, RED), new Stone(7, RED)));
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, RED), new Stone(5, BLUE), new Stone(6, RED)));
-		assertSet(INVALID, Arrays.asList(new Stone(4, RED), new Stone(5, RED)));
-		assertSet(INVALID,
-				Arrays.asList(new Stone(4, BLUE), new Stone(5, RED), new Stone(6, RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED),
+				new Stone(5, RED), new Stone(7, RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(4, RED), new Stone(5,
+				BLUE), new Stone(6, RED)));
+		assertSet(INVALID, 0,
+				Arrays.asList(new Stone(4, RED), new Stone(5, RED)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(4, BLUE), new Stone(5,
+				RED), new Stone(6, RED)));
 		// Regression test:
-		assertSet(INVALID, Arrays.asList(new Stone(12, ORANGE), new Stone(12,
-				BLACK), new Stone(7, BLUE)));
+		assertSet(INVALID, 0, Arrays.asList(new Stone(12, ORANGE), new Stone(
+				12, BLACK), new Stone(7, BLUE)));
 	}
 
 	// invalid Split