summaryrefslogtreecommitdiffstats
path: root/test/jrummikub/control/turn/TurnControlTest.java
diff options
context:
space:
mode:
Diffstat (limited to 'test/jrummikub/control/turn/TurnControlTest.java')
-rw-r--r--test/jrummikub/control/turn/TurnControlTest.java1129
1 files changed, 1129 insertions, 0 deletions
diff --git a/test/jrummikub/control/turn/TurnControlTest.java b/test/jrummikub/control/turn/TurnControlTest.java
new file mode 100644
index 0000000..150f3e9
--- /dev/null
+++ b/test/jrummikub/control/turn/TurnControlTest.java
@@ -0,0 +1,1129 @@
+package jrummikub.control.turn;
+
+import static jrummikub.model.StoneColor.BLACK;
+import static jrummikub.model.StoneColor.BLUE;
+import static jrummikub.model.StoneColor.RED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import jrummikub.control.ITurnTimer;
+import jrummikub.control.turn.HumanTurnControl;
+import jrummikub.model.IHand;
+import jrummikub.model.ITable;
+import jrummikub.model.MockHand;
+import jrummikub.model.MockTable;
+import jrummikub.model.Position;
+import jrummikub.model.Stone;
+import jrummikub.model.StoneColor;
+import jrummikub.model.StoneSet;
+import jrummikub.model.Table;
+import jrummikub.util.Event;
+import jrummikub.util.IEvent;
+import jrummikub.util.IListener;
+import jrummikub.util.Pair;
+import jrummikub.view.MockView;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Tests for {@link HumanTurnControl}
+ */
+public class TurnControlTest {
+ static class AccessibleTable extends Table {
+ StoneSet[] getSetArray() {
+ return objects.keySet().toArray(new StoneSet[0]);
+ }
+ }
+
+ class MockTimer implements ITurnTimer {
+ public boolean timerRunning = false;
+ public Event timeRunOutEvent = new Event();
+
+ @Override
+ public void startTimer() {
+ timerRunning = true;
+ }
+
+ @Override
+ public void stopTimer() {
+ timerRunning = false;
+ }
+
+ @Override
+ public IEvent getTimeRunOutEvent() {
+ return timeRunOutEvent;
+ }
+
+ }
+
+ HumanTurnControl testControl;
+ MockView mockView;
+ MockTimer mockTimer;
+ MockTable mockTable;
+ MockHand mockHand;
+ boolean eventFired;
+
+ private void checkTableDisplay(ITable table) {
+ Iterator<Pair<StoneSet, Position>> stoneSetsView = mockView.tablePanel.stoneSets
+ .iterator();
+ Iterator<Pair<StoneSet, Position>> stoneSetsModel = table.iterator();
+
+ while (stoneSetsView.hasNext()) {
+ assertTrue(stoneSetsModel.hasNext());
+ assertSame(stoneSetsView.next(), stoneSetsModel.next());
+ }
+ assertFalse(stoneSetsModel.hasNext());
+ }
+
+ private void checkHandDisplay(IHand hand) {
+ Iterator<Pair<Stone, Position>> stoneSetsView = mockView.handPanel.stones
+ .iterator();
+ Iterator<Pair<Stone, Position>> stoneSetsModel = hand.iterator();
+
+ while (stoneSetsView.hasNext()) {
+ assertTrue(stoneSetsModel.hasNext());
+ assertSame(stoneSetsView.next(), stoneSetsModel.next());
+ }
+ assertFalse(stoneSetsModel.hasNext());
+ }
+
+ /** */
+ @Before
+ public void setUp() {
+ mockView = new MockView();
+ mockTimer = new MockTimer();
+ mockTable = new MockTable();
+ mockHand = new MockHand();
+ testControl = new HumanTurnControl(mockHand, mockTable, mockView, mockTimer);
+ }
+
+ /** */
+ @Test
+ public void startTimer() {
+ testControl.startTurn();
+
+ assertTrue(mockTimer.timerRunning);
+ }
+
+ /** */
+ @SuppressWarnings("unchecked")
+ @Test
+ public void showInitialHand() {
+ mockView.displayStartTurnPanel = true;
+
+ List<Pair<Stone, Position>> stones = Arrays.asList(
+ new Pair<Stone, Position>(new Stone(RED), new Position(0, 0)),
+ new Pair<Stone, Position>(new Stone(BLACK), new Position(1, 0)));
+
+ mockHand.iterable = stones;
+
+ testControl = new HumanTurnControl(mockHand, mockTable, mockView, mockTimer);
+
+ testControl.startTurn();
+
+ int i = 0;
+ for (Pair<Stone, Position> pair : mockView.handPanel.stones) {
+ assertSame(stones.get(i), pair);
+ i++;
+ }
+ assertEquals(stones.size(), i);
+
+ assertFalse(mockView.displayStartTurnPanel);
+ }
+
+ /** */
+ @Test
+ public void viewEndOfTurn() {
+ testControl.startTurn();
+
+ eventFired = false;
+ mockTimer.timerRunning = true;
+
+ testControl.getEndOfTurnEvent().add(new IListener() {
+
+ @Override
+ public void handle() {
+ eventFired = true;
+ }
+ });
+
+ mockView.playerPanel.endTurnEvent.emit();
+
+ assertTrue(eventFired);
+ assertFalse(mockTimer.timerRunning);
+ assertTrue(mockView.playerPanel.endTurnEvent.listeners.isEmpty());
+ }
+
+ /** */
+ @Test
+ public void timerEndOfTurn() {
+ testControl.startTurn();
+
+ eventFired = false;
+ mockTimer.timerRunning = true;
+
+ testControl.getEndOfTurnEvent().add(new IListener() {
+
+ @Override
+ public void handle() {
+ eventFired = true;
+ }
+ });
+
+ mockTimer.timeRunOutEvent.emit();
+
+ assertTrue(eventFired);
+ assertFalse(mockTimer.timerRunning);
+ }
+
+ /** */
+ @Test
+ public void deselctOnEndOfTurn() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+
+ // Select first stone
+ mockView.handPanel.stoneClickEvent.emit(firstStone, false);
+ mockTimer.timeRunOutEvent.emit();
+
+ assertCollection(new ArrayList<Stone>());
+ }
+
+ /** */
+ @Test
+ public void selectStoneInHand() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+
+ // Select first stone
+ mockView.handPanel.stoneClickEvent.emit(firstStone, false);
+
+ assertCollection(Arrays.asList(firstStone));
+
+ // Select second stone
+ Stone secondStone = new Stone(StoneColor.BLACK);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, false);
+
+ assertCollection(Arrays.asList(secondStone));
+
+ }
+
+ /** */
+ @Test
+ public void collectStoneInHand() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+
+ // Select first stone
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+
+ assertCollection(Arrays.asList(firstStone));
+
+ // Select second stone
+ Stone secondStone = new Stone(StoneColor.BLACK);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, true);
+
+ assertCollection(Arrays.asList(firstStone, secondStone));
+
+ // De-select first stone
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+
+ assertCollection(Arrays.asList(secondStone));
+ }
+
+ /** */
+ @Test
+ public void deselectStoneInCollection() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+ Stone secondStone = new Stone(StoneColor.BLACK);
+
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, true);
+
+ mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(firstStone,
+ false);
+
+ assertCollection(Arrays.asList(secondStone));
+ }
+
+ /** */
+ @Test
+ public void reorderCollection() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+ Stone secondStone = new Stone(StoneColor.BLACK);
+
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, true);
+
+ mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(firstStone,
+ true);
+
+ assertCollection(Arrays.asList(secondStone, firstStone));
+ }
+
+ /** */
+ @Test
+ public void deselectWholeCollection() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+ Stone secondStone = new Stone(StoneColor.BLACK);
+
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, true);
+
+ mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(firstStone,
+ true);
+
+ mockView.tablePanel.stoneCollectionPanel.setClickEvent.emit(firstStone,
+ true);
+
+ assertCollection(new ArrayList<Stone>());
+ }
+
+ /** */
+ @Test
+ public void selectStoneOnTable() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(firstStone, false);
+
+ assertCollection(Arrays.asList(firstStone));
+
+ // Select second stone
+ Stone secondStone = new Stone(StoneColor.BLACK);
+ mockView.tablePanel.stoneClickEvent.emit(secondStone, false);
+
+ assertCollection(Arrays.asList(secondStone));
+
+ }
+
+ /** */
+ @Test
+ public void collectStoneOnTable() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(firstStone, true);
+
+ assertCollection(Arrays.asList(firstStone));
+
+ // Select second stone
+ Stone secondStone = new Stone(StoneColor.BLACK);
+ mockView.tablePanel.stoneClickEvent.emit(secondStone, true);
+
+ assertCollection(Arrays.asList(firstStone, secondStone));
+
+ // De-select first stone
+ mockView.tablePanel.stoneClickEvent.emit(firstStone, true);
+
+ assertCollection(Arrays.asList(secondStone));
+ }
+
+ /** */
+ @Test
+ public void selectSetOnTable() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(StoneColor.RED);
+ Stone stone2 = new Stone(StoneColor.BLACK);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1, stone2));
+ Stone stone3 = new Stone(1, StoneColor.RED);
+ Stone stone4 = new Stone(1, StoneColor.BLACK);
+ StoneSet set2 = new StoneSet(Arrays.asList(stone3, stone4));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone4, set2);
+
+ mockView.tablePanel.stoneClickEvent.emit(stone1, false);
+ mockView.tablePanel.setClickEvent.emit(stone1, false);
+ assertCollection(Arrays.asList(stone1, stone2));
+ mockView.tablePanel.stoneClickEvent.emit(stone4, false);
+ mockView.tablePanel.setClickEvent.emit(stone4, false);
+ assertCollection(Arrays.asList(stone3, stone4));
+ }
+
+ /** */
+ @Test
+ public void collectSetOnTable() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(StoneColor.RED);
+ Stone stone2 = new Stone(StoneColor.BLACK);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1, stone2));
+ Stone stone3 = new Stone(1, StoneColor.RED);
+ Stone stone4 = new Stone(1, StoneColor.BLACK);
+ StoneSet set2 = new StoneSet(Arrays.asList(stone3, stone4));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone4, set2);
+
+ mockView.tablePanel.stoneClickEvent.emit(stone1, true);
+ mockView.tablePanel.setClickEvent.emit(stone1, true);
+ assertCollection(Arrays.asList(stone1, stone2));
+ mockView.tablePanel.stoneClickEvent.emit(stone4, true);
+ mockView.tablePanel.setClickEvent.emit(stone4, true);
+ assertCollection(Arrays.asList(stone1, stone2, stone3, stone4));
+ }
+
+ /** */
+ @Test
+ public void rangeSelectOnTableReverse() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1, stone2, stone3, stone4));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone3, set1);
+
+ mockView.tablePanel.stoneClickEvent.emit(stone3, false);
+ mockView.tablePanel.rangeClickEvent.emit(stone1, true);
+
+ assertCollection(Arrays.asList(stone1, stone2, stone3));
+
+ }
+
+ /** */
+ @Test
+ public void rangeSelectOnTable() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1, stone2, stone3, stone4));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone3, set1);
+
+ mockView.tablePanel.stoneClickEvent.emit(stone1, false);
+ mockView.tablePanel.rangeClickEvent.emit(stone3, true);
+
+ assertCollection(Arrays.asList(stone1, stone2, stone3));
+
+ }
+
+ /** */
+ @Test
+ public void rangeCollectOnTable() {
+ testControl.startTurn();
+
+ Stone extraStone = new Stone(StoneColor.RED);
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1, stone2, stone3, stone4));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone3, set1);
+
+ mockView.tablePanel.stoneClickEvent.emit(extraStone, false);
+
+ mockView.tablePanel.stoneClickEvent.emit(stone1, true);
+ mockView.tablePanel.rangeClickEvent.emit(stone3, false);
+
+ assertCollection(Arrays.asList(extraStone, stone1, stone2, stone3));
+ }
+
+ /** */
+ @Test
+ public void rangeFailSelect() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1));
+ StoneSet set2 = new StoneSet(Arrays.asList(stone2));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone2, set2);
+
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(stone1, false);
+
+ assertCollection(Arrays.asList(stone1));
+
+ // Select second stone
+ mockView.tablePanel.rangeClickEvent.emit(stone2, false);
+
+ assertCollection(Arrays.asList(stone1, stone2));
+
+ }
+
+ /** */
+ @Test
+ public void rangeFailCollect() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1));
+ StoneSet set2 = new StoneSet(Arrays.asList(stone2));
+
+ mockTable.findStoneSet.put(stone1, set1);
+ mockTable.findStoneSet.put(stone2, set2);
+
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(stone1, true);
+
+ assertCollection(Arrays.asList(stone1));
+
+ // Select second stone
+ mockView.tablePanel.rangeClickEvent.emit(stone2, true);
+
+ assertCollection(Arrays.asList(stone1, stone2));
+ }
+
+ /** */
+ @Test
+ public void rangeSelectOnHandReverse() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ mockHand.drop(stone1, new Position(0, 0));
+ mockHand.drop(stone2, new Position(1.5f, 0));
+ mockHand.drop(stone3, new Position(0, 1));
+ mockHand.drop(stone4, new Position(1, 1));
+
+ mockView.handPanel.stoneClickEvent.emit(stone3, false);
+ mockView.handPanel.rangeClickEvent.emit(stone1, true);
+
+ assertCollection(Arrays.asList(stone1, stone2, stone3));
+ }
+
+ /** */
+ @Test
+ public void rangeSelectOnHand() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ mockHand.drop(stone1, new Position(0, 0));
+ mockHand.drop(stone2, new Position(1.5f, 0));
+ mockHand.drop(stone3, new Position(0, 1));
+ mockHand.drop(stone4, new Position(1, 1));
+
+ mockView.handPanel.stoneClickEvent.emit(stone1, false);
+ mockView.handPanel.rangeClickEvent.emit(stone3, true);
+
+ assertCollection(Arrays.asList(stone1, stone2, stone3));
+ }
+
+ /** */
+ @Test
+ public void rangeCollectOnHand() {
+ testControl.startTurn();
+
+ Stone extraStone = new Stone(StoneColor.RED);
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ Stone stone3 = new Stone(3, StoneColor.RED);
+ Stone stone4 = new Stone(4, StoneColor.RED);
+ mockHand.drop(stone1, new Position(0, 0));
+ mockHand.drop(stone2, new Position(1.5f, 0));
+ mockHand.drop(stone3, new Position(0, 1));
+ mockHand.drop(stone4, new Position(1, 1));
+
+ mockView.handPanel.stoneClickEvent.emit(extraStone, false);
+
+ mockView.handPanel.stoneClickEvent.emit(stone1, true);
+ mockView.handPanel.rangeClickEvent.emit(stone3, false);
+ assertCollection(Arrays.asList(extraStone, stone1, stone2, stone3));
+ }
+
+ /** */
+ @Test
+ public void rangeFailSelectHand() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1));
+ mockTable.findStoneSet.put(stone1, set1);
+ mockHand.drop(stone2, new Position(0, 0));
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(stone1, false);
+
+ assertCollection(Arrays.asList(stone1));
+
+ // Select second stone
+ mockView.handPanel.rangeClickEvent.emit(stone2, false);
+
+ assertCollection(Arrays.asList(stone1, stone2));
+
+ }
+
+ /** */
+ @Test
+ public void rangeFailCollectHand() {
+ testControl.startTurn();
+
+ Stone stone1 = new Stone(1, StoneColor.RED);
+ Stone stone2 = new Stone(2, StoneColor.RED);
+ StoneSet set1 = new StoneSet(Arrays.asList(stone1));
+ mockTable.findStoneSet.put(stone1, set1);
+ mockHand.drop(stone2, new Position(0, 0));
+ // Select first stone
+ mockView.tablePanel.stoneClickEvent.emit(stone1, false);
+
+ assertCollection(Arrays.asList(stone1));
+
+ // Select second stone
+ mockView.handPanel.rangeClickEvent.emit(stone2, true);
+
+ assertCollection(Arrays.asList(stone1, stone2));
+ }
+
+ private void assertCollection(List<Stone> expected) {
+ ArrayList<Stone> selectedStones = new ArrayList<Stone>(
+ mockView.selectedStones);
+ ArrayList<Stone> expectedStones = new ArrayList<Stone>(expected);
+ assertEquals(expectedStones, selectedStones);
+ }
+
+ /** */
+ @Test
+ public void testAddLeft() {
+ AccessibleTable table = new AccessibleTable();
+ HumanTurnControl turnControl = new HumanTurnControl(mockHand, table, mockView,
+ mockTimer);
+ turnControl.startTurn();
+ Stone blueOne = new Stone(1, BLUE);
+ Stone redOne = new Stone(1, RED);
+ Stone blackOne = new Stone(1, BLACK);
+ Stone blueTwo = new Stone(2, BLUE);
+ Stone blueThree = new Stone(3, BLUE);
+ Stone blueFour = new Stone(4, BLUE);
+ Stone redTwo = new Stone(2, RED);
+ Stone redThree = new Stone(3, RED);
+ Stone redFour = new Stone(4, RED);
+ Stone blackTwo = new Stone(2, BLACK);
+ Stone blackThree = new Stone(3, BLACK);
+ Stone blackFour = new Stone(4, BLACK);
+ Stone blackFive = new Stone(5, BLACK);
+ StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne, blackOne,
+ redTwo, redThree, redFour, blackTwo, blackThree));
+ StoneSet oldSet2 = new StoneSet(
+ Arrays.asList(blueTwo, blackFour, blackFive));
+ table.drop(oldSet1, new Position(0, 0));
+ table.drop(oldSet2, new Position(0, 0));
+ mockHand.drop(blueThree, new Position(0, 0));
+ mockHand.drop(blueFour, new Position(0, 0));
+ mockView.handPanel.stoneClickEvent.emit(blueThree, false);
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.leftConnectorClickEvent.emit(oldSet1);
+ // handcheck
+ assertEquals(1, mockHand.getSize());
+ assertSame(mockHand.stones.get(0).getFirst(), blueFour);
+ // tablecheck
+ assertEquals(2, table.getSize());
+ StoneSet newSet1, newSet2;
+ if (table.getSetArray()[0].size() == 3) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ assertSame(oldSet2, newSet2);
+ // setcheck
+ assertEquals(9, newSet1.size());
+ assertSame(newSet1.get(0), blueThree);
+ assertSame(newSet1.get(1), redOne);
+ assertSame(newSet1.get(2), redThree);
+ assertSame(newSet1.get(3), blueOne);
+ assertSame(newSet1.get(4), blackOne);
+ assertSame(newSet1.get(5), redTwo);
+ assertSame(newSet1.get(6), redFour);
+ assertSame(newSet1.get(7), blackTwo);
+ assertSame(newSet1.get(8), blackThree);
+
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.leftConnectorClickEvent.emit(oldSet2);
+ // handcheck
+ assertEquals(1, mockHand.getSize());
+ assertSame(mockHand.stones.get(0).getFirst(), blueFour);
+ // tablecheck
+ assertEquals(2, table.getSize());
+ if (table.getSetArray()[0].size() == 5) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ // setcheck1
+ assertEquals(7, newSet1.size());
+ assertSame(newSet1.get(0), blueThree);
+ assertSame(newSet1.get(1), blueOne);
+ assertSame(newSet1.get(2), blackOne);
+ assertSame(newSet1.get(3), redTwo);
+ assertSame(newSet1.get(4), redFour);
+ assertSame(newSet1.get(5), blackTwo);
+ assertSame(newSet1.get(6), blackThree);
+ // setcheck2
+ assertEquals(5, newSet2.size());
+ assertSame(newSet2.get(0), redOne);
+ assertSame(newSet2.get(1), redThree);
+ assertSame(newSet2.get(2), blueTwo);
+ assertSame(newSet2.get(3), blackFour);
+ assertSame(newSet2.get(4), blackFive);
+ // versuche, links was wegzunehmen und wieder anzuhängen
+ mockView.handPanel.stoneClickEvent.emit(blueFour, false);
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.leftConnectorClickEvent.emit(newSet2);
+
+ // handcheck
+ assertEquals(0, mockHand.getSize());
+ // tablecheck
+ assertEquals(2, table.getSize());
+ if (table.getSetArray()[0].size() == 6) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ // setcheck1
+ assertEquals(7, newSet1.size());
+ // setcheck2
+ assertEquals(6, newSet2.size());
+ assertSame(newSet2.get(0), blueFour);
+ assertSame(newSet2.get(1), redOne);
+ assertSame(newSet2.get(2), redThree);
+ assertSame(newSet2.get(3), blueTwo);
+ assertSame(newSet2.get(4), blackFour);
+ assertSame(newSet2.get(5), blackFive);
+ }
+
+ /** */
+ @Test
+ public void testAddRight() {
+ AccessibleTable table = new AccessibleTable();
+ HumanTurnControl turnControl = new HumanTurnControl(mockHand, table, mockView,
+ mockTimer);
+ turnControl.startTurn();
+ Stone blueOne = new Stone(1, BLUE);
+ Stone redOne = new Stone(1, RED);
+ Stone blackOne = new Stone(1, BLACK);
+ Stone blueTwo = new Stone(2, BLUE);
+ Stone blueThree = new Stone(3, BLUE);
+ Stone blueFour = new Stone(4, BLUE);
+ Stone redTwo = new Stone(2, RED);
+ Stone redThree = new Stone(3, RED);
+ Stone redFour = new Stone(4, RED);
+ Stone blackTwo = new Stone(2, BLACK);
+ Stone blackThree = new Stone(3, BLACK);
+ Stone blackFour = new Stone(4, BLACK);
+ Stone blackFive = new Stone(5, BLACK);
+ StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne, blackOne,
+ redTwo, redThree, redFour, blackTwo, blackThree));
+ StoneSet oldSet2 = new StoneSet(
+ Arrays.asList(blueTwo, blackFour, blackFive));
+ table.drop(oldSet1, new Position(0, 0));
+ table.drop(oldSet2, new Position(0, 0));
+ mockHand.drop(blueThree, new Position(0, 0));
+ mockHand.drop(blueFour, new Position(0, 0));
+ mockView.handPanel.stoneClickEvent.emit(blueThree, false);
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.rightConnectorClickEvent.emit(oldSet1);
+ // handcheck
+ assertEquals(1, mockHand.getSize());
+ assertSame(mockHand.stones.get(0).getFirst(), blueFour);
+ // tablecheck
+ assertEquals(2, table.getSize());
+ StoneSet newSet1, newSet2;
+ if (table.getSetArray()[0].size() == 3) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ assertSame(oldSet2, newSet2);
+ // setcheck
+ assertEquals(9, newSet1.size());
+ assertSame(newSet1.get(0), blueOne);
+ assertSame(newSet1.get(1), blackOne);
+ assertSame(newSet1.get(2), redTwo);
+ assertSame(newSet1.get(3), redFour);
+ assertSame(newSet1.get(4), blackTwo);
+ assertSame(newSet1.get(5), blackThree);
+ assertSame(newSet1.get(6), blueThree);
+ assertSame(newSet1.get(7), redOne);
+ assertSame(newSet1.get(8), redThree);
+
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.rightConnectorClickEvent.emit(oldSet2);
+ // handcheck
+ assertEquals(1, mockHand.getSize());
+ assertSame(mockHand.stones.get(0).getFirst(), blueFour);
+ // tablecheck
+ assertEquals(2, table.getSize());
+ if (table.getSetArray()[0].size() == 5) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ // setcheck1
+ assertEquals(7, newSet1.size());
+ assertSame(newSet1.get(0), blueOne);
+ assertSame(newSet1.get(1), blackOne);
+ assertSame(newSet1.get(2), redTwo);
+ assertSame(newSet1.get(3), redFour);
+ assertSame(newSet1.get(4), blackTwo);
+ assertSame(newSet1.get(5), blackThree);
+ assertSame(newSet1.get(6), blueThree);
+ // setcheck2
+ assertEquals(5, newSet2.size());
+ assertSame(newSet2.get(0), blueTwo);
+ assertSame(newSet2.get(1), blackFour);
+ assertSame(newSet2.get(2), blackFive);
+ assertSame(newSet2.get(3), redOne);
+ assertSame(newSet2.get(4), redThree);
+ // versuche, rechts was wegzunehmen und wieder anzuhängen
+ mockView.handPanel.stoneClickEvent.emit(blueFour, false);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.rightConnectorClickEvent.emit(newSet2);
+
+ // handcheck
+ assertEquals(0, mockHand.getSize());
+ // tablecheck
+ assertEquals(2, table.getSize());
+ if (table.getSetArray()[0].size() == 6) {
+ newSet2 = table.getSetArray()[0];
+ newSet1 = table.getSetArray()[1];
+ } else {
+ newSet1 = table.getSetArray()[0];
+ newSet2 = table.getSetArray()[1];
+ }
+ // setcheck1
+ assertEquals(7, newSet1.size());
+ // setcheck2
+ assertEquals(6, newSet2.size());
+ assertSame(newSet2.get(0), blueTwo);
+ assertSame(newSet2.get(1), blackFour);
+ assertSame(newSet2.get(2), blackFive);
+ assertSame(newSet2.get(3), redOne);
+ assertSame(newSet2.get(4), blueFour);
+ assertSame(newSet2.get(5), redThree);
+ }
+
+ /** */
+ @Test
+ public void testAddNewSet() {
+ AccessibleTable table = new AccessibleTable();
+ HumanTurnControl turnControl = new HumanTurnControl(mockHand, table, mockView,
+ mockTimer);
+ turnControl.startTurn();
+ Stone blueOne = new Stone(1, BLUE);
+ Stone redOne = new Stone(1, RED);
+ Stone blackOne = new Stone(1, BLACK);
+ Stone blueTwo = new Stone(2, BLUE);
+ Stone blueThree = new Stone(3, BLUE);
+ Stone blueFour = new Stone(4, BLUE);
+ Stone redTwo = new Stone(2, RED);
+ Stone redThree = new Stone(3, RED);
+ Stone redFour = new Stone(4, RED);
+ Stone blackTwo = new Stone(2, BLACK);
+ Stone blackThree = new Stone(3, BLACK);
+ Stone blackFour = new Stone(4, BLACK);
+ Stone blackFive = new Stone(5, BLACK);
+ StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne, blackOne,
+ redTwo, redThree, redFour, blackTwo, blackThree));
+ StoneSet oldSet2 = new StoneSet(
+ Arrays.asList(blueTwo, blackFour, blackFive));
+ table.drop(oldSet1, new Position(0, 0));
+ table.drop(oldSet2, new Position(0, 0));
+ mockHand.drop(blueThree, new Position(0, 0));
+ mockHand.drop(blueFour, new Position(0, 0));
+ mockView.handPanel.stoneClickEvent.emit(blueThree, false);
+ mockView.tablePanel.stoneClickEvent.emit(redOne, true);
+ mockView.tablePanel.stoneClickEvent.emit(redThree, true);
+ mockView.tablePanel.stoneClickEvent.emit(blueTwo, true);
+ mockView.tablePanel.clickEvent.emit(new Position(0, 0));
+ // handcheck
+ assertEquals(1, mockHand.getSize());
+ assertSame(blueFour, mockHand.stones.get(0).getFirst());
+ // tablecheck
+ StoneSet newSet1, newSet2, newSet3;
+ assertEquals(3, table.getSize());
+ if (table.getSetArray()[0].size() == 2) {
+ newSet2 = table.getSetArray()[0];
+ if (table.getSetArray()[1].size() == 4) {
+ newSet3 = table.getSetArray()[1];
+ newSet1 = table.getSetArray()[2];
+ } else {
+ newSet3 = table.getSetArray()[2];
+ newSet1 = table.getSetArray()[1];
+ }
+ } else if (table.getSetArray()[0].size() == 4) {
+ newSet3 = table.getSetArray()[0];
+ if (table.getSetArray()[1].size() == 2) {
+ newSet2 = table.getSetArray()[1];
+ newSet1 = table.getSetArray()[2];
+ } else {
+ newSet2 = table.getSetArray()[2];
+ newSet1 = table.getSetArray()[1];
+ }
+ } else {
+ newSet1 = table.getSetArray()[0];
+ if (table.getSetArray()[1].size() == 2) {
+ newSet2 = table.getSetArray()[1];
+ newSet3 = table.getSetArray()[2];
+ } else {
+ newSet2 = table.getSetArray()[2];
+ newSet3 = table.getSetArray()[1];
+ }
+ }
+
+ // setcheck1
+ assertEquals(6, newSet1.size());
+ assertSame(newSet1.get(0), blueOne);
+ assertSame(newSet1.get(1), blackOne);
+ assertSame(newSet1.get(2), redTwo);
+ assertSame(newSet1.get(3), redFour);
+ assertSame(newSet1.get(4), blackTwo);
+ assertSame(newSet1.get(5), blackThree);
+ // setcheck2
+ assertEquals(2, newSet2.size());
+ assertSame(newSet2.get(0), blackFour);
+ assertSame(newSet2.get(1), blackFive);
+ // setcheck1
+ assertEquals(4, newSet3.size());
+ assertSame(newSet3.get(0), blueThree);
+ assertSame(newSet3.get(1), redOne);
+ assertSame(newSet3.get(2), redThree);
+ assertSame(newSet3.get(3), blueTwo);
+
+ checkTableDisplay(table);
+ checkHandDisplay(mockHand);
+ }
+
+ /** */
+ @Test
+ public void testSortByGroups() {
+ testControl.startTurn();
+
+ Stone red1 = new Stone(1, StoneColor.RED);
+ Stone blue2 = new Stone(2, StoneColor.BLUE);
+ Stone red4 = new Stone(4, StoneColor.RED);
+ Stone red3 = new Stone(3, StoneColor.RED);
+ Stone orange10 = new Stone(10, StoneColor.ORANGE);
+ Stone blue1 = new Stone(1, StoneColor.BLUE);
+ Stone blue4 = new Stone(4, StoneColor.BLUE);
+ Stone blue4a = new Stone(4, StoneColor.BLUE);
+ Stone joker = new Stone(StoneColor.BLACK);
+ Stone black5 = new Stone(5, StoneColor.BLACK);
+ Stone orange13 = new Stone(13, StoneColor.ORANGE);
+ Stone red11 = new Stone(11, StoneColor.RED);
+ Stone black10 = new Stone(10, StoneColor.BLACK);
+ mockHand.drop(red1, new Position(0, 0));
+ mockHand.drop(blue2, new Position(0, 0));
+ mockHand.drop(red4, new Position(0, 0));
+ mockHand.drop(red3, new Position(0, 0));
+ mockHand.drop(orange10, new Position(0, 0));
+ mockHand.drop(blue1, new Position(0, 0));
+ mockHand.drop(blue4, new Position(0, 0));
+ mockHand.drop(blue4a, new Position(0, 0));
+ mockHand.drop(joker, new Position(0, 0));
+ mockHand.drop(black5, new Position(0, 0));
+ mockHand.drop(orange13, new Position(0, 0));
+ mockHand.drop(red11, new Position(0, 0));
+ mockHand.drop(black10, new Position(0, 0));
+
+ mockView.playerPanel.sortByGroupsEvent.emit();
+
+ List<Pair<Stone, Position>> stones = new ArrayList<Pair<Stone, Position>>(
+ mockHand.stones);
+ Collections.sort(stones, new HumanTurnControl.HandStonePositionComparator());
+
+ assertEquals(stones.size(), 13);
+
+ assertSame(stones.get(0).getFirst(), blue1);
+ assertSame(stones.get(1).getFirst(), red1);
+ assertSame(stones.get(2).getFirst(), blue2);
+ assertSame(stones.get(3).getFirst(), red3);
+
+ assertTrue(stones.get(4).getFirst() == blue4
+ || stones.get(4).getFirst() == blue4a);
+ assertTrue(stones.get(5).getFirst() == blue4
+ || stones.get(5).getFirst() == blue4a);
+
+ assertSame(stones.get(6).getFirst(), red4);
+ assertSame(stones.get(7).getFirst(), black5);
+ assertSame(stones.get(8).getFirst(), black10);
+ assertSame(stones.get(9).getFirst(), orange10);
+ assertSame(stones.get(10).getFirst(), red11);
+ assertSame(stones.get(11).getFirst(), orange13);
+ assertSame(stones.get(12).getFirst(), joker);
+
+ checkHandDisplay(mockHand);
+ }
+
+ /** */
+ @Test
+ public void testSortByRuns() {
+ testControl.startTurn();
+
+ Stone red1 = new Stone(1, StoneColor.RED);
+ Stone blue2 = new Stone(2, StoneColor.BLUE);
+ Stone red4 = new Stone(4, StoneColor.RED);
+ Stone red3 = new Stone(3, StoneColor.RED);
+ Stone orange10 = new Stone(10, StoneColor.ORANGE);
+ Stone blue1 = new Stone(1, StoneColor.BLUE);
+ Stone blue4 = new Stone(4, StoneColor.BLUE);
+ Stone blue4a = new Stone(4, StoneColor.BLUE);
+ Stone joker = new Stone(StoneColor.BLACK);
+ Stone black5 = new Stone(5, StoneColor.BLACK);
+ Stone orange13 = new Stone(13, StoneColor.ORANGE);
+ Stone red11 = new Stone(11, StoneColor.RED);
+ Stone black10 = new Stone(10, StoneColor.BLACK);
+ mockHand.drop(red1, new Position(0, 0));
+ mockHand.drop(blue2, new Position(0, 0));
+ mockHand.drop(red4, new Position(0, 0));
+ mockHand.drop(red3, new Position(0, 0));
+ mockHand.drop(orange10, new Position(0, 0));
+ mockHand.drop(blue1, new Position(0, 0));
+ mockHand.drop(blue4, new Position(0, 0));
+ mockHand.drop(blue4a, new Position(0, 0));
+ mockHand.drop(joker, new Position(0, 0));
+ mockHand.drop(black5, new Position(0, 0));
+ mockHand.drop(orange13, new Position(0, 0));
+ mockHand.drop(red11, new Position(0, 0));
+ mockHand.drop(black10, new Position(0, 0));
+
+ mockView.playerPanel.sortByRunsEvent.emit();
+
+ List<Pair<Stone, Position>> stones = new ArrayList<Pair<Stone, Position>>(
+ mockHand.stones);
+ Collections.sort(stones, new HumanTurnControl.HandStonePositionComparator());
+
+ assertEquals(stones.size(), 13);
+
+ assertSame(stones.get(0).getFirst(), black5);
+ assertSame(stones.get(1).getFirst(), black10);
+ assertSame(stones.get(2).getFirst(), orange10);
+ assertSame(stones.get(3).getFirst(), orange13);
+ assertSame(stones.get(4).getFirst(), blue1);
+ assertSame(stones.get(5).getFirst(), blue2);
+
+ assertTrue(stones.get(6).getFirst() == blue4
+ || stones.get(6).getFirst() == blue4a);
+ assertTrue(stones.get(7).getFirst() == blue4
+ || stones.get(7).getFirst() == blue4a);
+
+ assertSame(stones.get(8).getFirst(), red1);
+ assertSame(stones.get(9).getFirst(), red3);
+ assertSame(stones.get(10).getFirst(), red4);
+ assertSame(stones.get(11).getFirst(), red11);
+ assertSame(stones.get(12).getFirst(), joker);
+
+ checkHandDisplay(mockHand);
+ }
+
+ /** */
+ @Test
+ public void testDropHandValid() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+ Stone secondStone = new Stone(StoneColor.BLACK);
+
+ mockHand.drop(firstStone, new Position(0, 0));
+ mockHand.drop(secondStone, new Position(1, 0));
+
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+ mockView.handPanel.stoneClickEvent.emit(secondStone, true);
+
+ mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));
+
+ assertCollection(new ArrayList<Stone>());
+
+ Set<Stone> expected = new HashSet<Stone>(Arrays.asList(firstStone,
+ secondStone));
+ assertEquals(expected, mockHand.pickups);
+
+ Set<Stone> handStones = new HashSet<Stone>();
+ for (Pair<Stone, Position> stone : mockHand.stones) {
+ assertEquals(stone.getSecond().getY(), 0, 0.0001);
+ handStones.add(stone.getFirst());
+ }
+ assertEquals(expected, handStones);
+ }
+
+ /** */
+ @Test
+ public void testDropHandInvalid() {
+ testControl.startTurn();
+
+ Stone firstStone = new Stone(StoneColor.RED);
+ Stone secondStone = new Stone(StoneColor.BLACK);
+ Stone thirdStone = new Stone(13, StoneColor.BLACK);
+
+ mockHand.drop(firstStone, new Position(0, 0));
+ mockHand.drop(thirdStone, new Position(1, 0));
+
+ mockView.handPanel.stoneClickEvent.emit(firstStone, true);
+ mockView.tablePanel.stoneClickEvent.emit(secondStone, true);
+ mockView.handPanel.stoneClickEvent.emit(thirdStone, true);
+
+ mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));
+
+ assertCollection(Arrays.asList(secondStone));
+
+ Set<Stone> expected = new HashSet<Stone>(Arrays.asList(firstStone,
+ thirdStone));
+ assertEquals(expected, mockHand.pickups);
+
+ Set<Stone> handStones = new HashSet<Stone>();
+ for (Pair<Stone, Position> stone : mockHand.stones) {
+ assertEquals(stone.getSecond().getY(), 0, 0.0001);
+ handStones.add(stone.getFirst());
+ }
+ assertEquals(expected, handStones);
+ }
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-29 13:54:46 +0200