From 73f6fb9c1b12e70896ee431af326bef0a7235b4f Mon Sep 17 00:00:00 2001 From: Jannis Harder Date: Sun, 29 May 2011 19:46:50 +0200 Subject: Created interface and abstract base class for turn control git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@307 72836036-5685-4462-b002-a69064685172 --- test/jrummikub/control/turn/TurnControlTest.java | 1129 ++++++++++++++++++++++ 1 file changed, 1129 insertions(+) create mode 100644 test/jrummikub/control/turn/TurnControlTest.java (limited to 'test/jrummikub/control/turn/TurnControlTest.java') 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> stoneSetsView = mockView.tablePanel.stoneSets + .iterator(); + Iterator> stoneSetsModel = table.iterator(); + + while (stoneSetsView.hasNext()) { + assertTrue(stoneSetsModel.hasNext()); + assertSame(stoneSetsView.next(), stoneSetsModel.next()); + } + assertFalse(stoneSetsModel.hasNext()); + } + + private void checkHandDisplay(IHand hand) { + Iterator> stoneSetsView = mockView.handPanel.stones + .iterator(); + Iterator> 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> stones = Arrays.asList( + new Pair(new Stone(RED), new Position(0, 0)), + new Pair(new Stone(BLACK), new Position(1, 0))); + + mockHand.iterable = stones; + + testControl = new HumanTurnControl(mockHand, mockTable, mockView, mockTimer); + + testControl.startTurn(); + + int i = 0; + for (Pair 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()); + } + + /** */ + @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()); + } + + /** */ + @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 expected) { + ArrayList selectedStones = new ArrayList( + mockView.selectedStones); + ArrayList expectedStones = new ArrayList(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> stones = new ArrayList>( + 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> stones = new ArrayList>( + 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()); + + Set expected = new HashSet(Arrays.asList(firstStone, + secondStone)); + assertEquals(expected, mockHand.pickups); + + Set handStones = new HashSet(); + for (Pair 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 expected = new HashSet(Arrays.asList(firstStone, + thirdStone)); + assertEquals(expected, mockHand.pickups); + + Set handStones = new HashSet(); + for (Pair stone : mockHand.stones) { + assertEquals(stone.getSecond().getY(), 0, 0.0001); + handStones.add(stone.getFirst()); + } + assertEquals(expected, handStones); + } + +} -- cgit v1.2.3