ea8a675cee
git-svn-id: svn://sunsvr01.isp.uni-luebeck.de/swproj13/trunk@567 72836036-5685-4462-b002-a69064685172
1049 lines
32 KiB
Java
1049 lines
32 KiB
Java
package jrummikub.control.turn;
|
|
|
|
import static jrummikub.model.StoneColor.*;
|
|
import static org.junit.Assert.*;
|
|
|
|
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.RoundControl;
|
|
import jrummikub.control.RoundControl.InvalidTurnInfo;
|
|
import jrummikub.control.turn.ITurnControl.TurnInfo;
|
|
import jrummikub.model.GameSettings;
|
|
import jrummikub.model.IHand;
|
|
import jrummikub.model.IRoundState;
|
|
import jrummikub.model.ITable;
|
|
import jrummikub.model.MockHand;
|
|
import jrummikub.model.MockPlayer;
|
|
import jrummikub.model.MockRoundState;
|
|
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.IListener2;
|
|
import jrummikub.util.Pair;
|
|
import jrummikub.view.IView.BottomPanelType;
|
|
import jrummikub.view.MockView;
|
|
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
|
|
/**
|
|
* Tests for {@link HumanTurnControl}
|
|
*/
|
|
public class TurnControlTest {
|
|
@SuppressWarnings("serial")
|
|
static class AccessibleTable extends Table {
|
|
StoneSet[] getSetArray() {
|
|
return objects.keySet().toArray(new StoneSet[0]);
|
|
}
|
|
|
|
AccessibleTable() {
|
|
super(new GameSettings());
|
|
}
|
|
}
|
|
|
|
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;
|
|
MockPlayer mockPlayer;
|
|
MockView mockView;
|
|
MockTimer mockTimer;
|
|
MockTable mockTable;
|
|
MockHand mockHand;
|
|
private MockRoundState mockRoundState;
|
|
boolean eventFired;
|
|
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);
|
|
Stone redJoker = new Stone(RED);
|
|
Stone blackJoker = new Stone(BLACK);
|
|
Stone orange10 = new Stone(10, StoneColor.ORANGE);
|
|
Stone blue4a = new Stone(4, StoneColor.BLUE);
|
|
Stone orange13 = new Stone(13, StoneColor.ORANGE);
|
|
Stone red11 = new Stone(11, StoneColor.RED);
|
|
Stone black10 = new Stone(10, StoneColor.BLACK);
|
|
Stone black13 = new Stone(13, StoneColor.BLACK);
|
|
Stone orangeOne = new Stone(1, StoneColor.ORANGE);
|
|
|
|
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();
|
|
mockRoundState = new MockRoundState();
|
|
mockTimer = new MockTimer();
|
|
mockTable = new MockTable();
|
|
|
|
mockRoundState.table = mockTable;
|
|
mockHand = new MockHand();
|
|
mockRoundState.players.get(0).hand = mockHand;
|
|
mockPlayer = new MockPlayer(null, null);
|
|
mockPlayer.hand = mockHand;
|
|
testControl = new HumanTurnControl(mockTimer);
|
|
testControl.setup(new ITurnControl.TurnInfo(mockRoundState,
|
|
TurnMode.NORMAL_TURN, false), new GameSettings(), mockView);
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void startTimer() {
|
|
testControl.startTurn();
|
|
|
|
assertTrue(mockTimer.timerRunning);
|
|
}
|
|
|
|
/** */
|
|
@SuppressWarnings("unchecked")
|
|
@Test
|
|
public void showInitialHand() {
|
|
mockRoundState.turnNumber = -1;
|
|
mockView.bottomPanelType = BottomPanelType.START_TURN_PANEL;
|
|
|
|
List<Pair<Stone, Position>> stones = Arrays.asList(
|
|
new Pair<Stone, Position>(redJoker, new Position(0, 0)),
|
|
new Pair<Stone, Position>(blackJoker, new Position(1, 0)));
|
|
|
|
mockHand.iterable = stones;
|
|
mockRoundState.players.get(0).hand = mockHand;
|
|
|
|
testControl = new HumanTurnControl(mockTimer);
|
|
testControl.setup(new ITurnControl.TurnInfo(mockRoundState,
|
|
TurnMode.INSPECT_ONLY, false), new GameSettings(), mockView);
|
|
testControl.startTurn();
|
|
mockView.startTurnEvent.emit();
|
|
|
|
int i = 0;
|
|
for (Pair<Stone, Position> pair : mockView.handPanel.stones) {
|
|
assertSame(stones.get(i), pair);
|
|
i++;
|
|
}
|
|
assertEquals(stones.size(), i);
|
|
|
|
assertSame(BottomPanelType.HUMAN_HAND_PANEL, mockView.bottomPanelType);
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void viewEndOfTurn() {
|
|
testControl.startTurn();
|
|
|
|
eventFired = false;
|
|
mockTimer.timerRunning = true;
|
|
|
|
testControl.getEndOfTurnEvent().add(
|
|
new IListener2<IRoundState, RoundControl.InvalidTurnInfo>() {
|
|
@Override
|
|
public void handle(IRoundState roundState,
|
|
RoundControl.InvalidTurnInfo invalidTurnInfo) {
|
|
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 IListener2<IRoundState, RoundControl.InvalidTurnInfo>() {
|
|
@Override
|
|
public void handle(IRoundState value1,
|
|
InvalidTurnInfo value2) {
|
|
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();
|
|
|
|
// Select first stone
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, false);
|
|
|
|
assertCollection(Arrays.asList(redJoker));
|
|
|
|
// Select second stone
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, false);
|
|
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void collectStoneInHand() {
|
|
testControl.startTurn();
|
|
|
|
// Select first stone
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
|
|
assertCollection(Arrays.asList(redJoker));
|
|
|
|
// Select second stone
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, true);
|
|
|
|
assertCollection(Arrays.asList(redJoker, blackJoker));
|
|
|
|
// De-select first stone
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void deselectStoneInCollection() {
|
|
testControl.startTurn();
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, true);
|
|
|
|
mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(redJoker,
|
|
false);
|
|
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void reorderCollection() {
|
|
testControl.startTurn();
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, true);
|
|
|
|
mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(
|
|
blackJoker, true);
|
|
|
|
assertCollection(Arrays.asList(redJoker, blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void deselectWholeCollection() {
|
|
testControl.startTurn();
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, true);
|
|
|
|
mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(redJoker,
|
|
true);
|
|
|
|
mockView.tablePanel.stoneCollectionPanel.setClickEvent.emit(redJoker,
|
|
true);
|
|
|
|
assertCollection(new ArrayList<Stone>());
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void selectStoneOnTable() {
|
|
testControl.startTurn();
|
|
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, false);
|
|
assertCollection(Arrays.asList(redJoker));
|
|
|
|
// Select second stone
|
|
mockView.tablePanel.stoneClickEvent.emit(blackJoker, false);
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void collectStoneOnTable() {
|
|
testControl.startTurn();
|
|
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
|
|
assertCollection(Arrays.asList(redJoker));
|
|
|
|
// Select second stone
|
|
mockView.tablePanel.stoneClickEvent.emit(blackJoker, true);
|
|
assertCollection(Arrays.asList(redJoker, blackJoker));
|
|
|
|
// De-select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void selectSetOnTable() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redJoker, blackJoker));
|
|
StoneSet set2 = new StoneSet(Arrays.asList(redOne, blackOne));
|
|
|
|
mockTable.findStoneSet.put(redJoker, set1);
|
|
mockTable.findStoneSet.put(blackOne, set2);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, false);
|
|
mockView.tablePanel.setClickEvent.emit(redJoker, false);
|
|
assertCollection(Arrays.asList(redJoker, blackJoker));
|
|
mockView.tablePanel.stoneClickEvent.emit(blackOne, false);
|
|
mockView.tablePanel.setClickEvent.emit(blackOne, false);
|
|
assertCollection(Arrays.asList(redOne, blackOne));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void collectSetOnTable() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redJoker, blackJoker));
|
|
StoneSet set2 = new StoneSet(Arrays.asList(redOne, blackOne));
|
|
|
|
mockTable.findStoneSet.put(redJoker, set1);
|
|
mockTable.findStoneSet.put(blackOne, set2);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.tablePanel.setClickEvent.emit(redJoker, true);
|
|
assertCollection(Arrays.asList(redJoker, blackJoker));
|
|
mockView.tablePanel.stoneClickEvent.emit(blackOne, true);
|
|
mockView.tablePanel.setClickEvent.emit(blackOne, true);
|
|
assertCollection(Arrays.asList(redJoker, blackJoker, redOne, blackOne));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeSelectOnTableReverse() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
|
|
redFour));
|
|
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockTable.findStoneSet.put(redThree, set1);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redThree, false);
|
|
mockView.tablePanel.rangeClickEvent.emit(redOne, true);
|
|
|
|
assertCollection(Arrays.asList(redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeSelectOnTable() {
|
|
testControl.startTurn();
|
|
|
|
Stone stone4 = new Stone(4, StoneColor.RED);
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
|
|
stone4));
|
|
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockTable.findStoneSet.put(redThree, set1);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, false);
|
|
mockView.tablePanel.rangeClickEvent.emit(redThree, true);
|
|
|
|
assertCollection(Arrays.asList(redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeCollectOnTable() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
|
|
redFour));
|
|
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockTable.findStoneSet.put(redThree, set1);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redJoker, false);
|
|
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, true);
|
|
mockView.tablePanel.rangeClickEvent.emit(redThree, false);
|
|
|
|
assertCollection(Arrays.asList(redJoker, redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeFailSelect() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne));
|
|
StoneSet set2 = new StoneSet(Arrays.asList(redTwo));
|
|
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockTable.findStoneSet.put(redTwo, set2);
|
|
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, false);
|
|
assertCollection(Arrays.asList(redOne));
|
|
|
|
// Select second stone
|
|
mockView.tablePanel.rangeClickEvent.emit(redTwo, false);
|
|
assertCollection(Arrays.asList(redOne, redTwo));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeFailCollect() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne));
|
|
StoneSet set2 = new StoneSet(Arrays.asList(redTwo));
|
|
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockTable.findStoneSet.put(redTwo, set2);
|
|
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, true);
|
|
assertCollection(Arrays.asList(redOne));
|
|
|
|
// Select second stone
|
|
mockView.tablePanel.rangeClickEvent.emit(redTwo, true);
|
|
assertCollection(Arrays.asList(redOne, redTwo));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeSelectOnHandReverse() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redOne, new Position(0, 0));
|
|
mockHand.drop(redTwo, new Position(1.5f, 0));
|
|
mockHand.drop(redThree, new Position(0, 1));
|
|
mockHand.drop(redFour, new Position(1, 1));
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redThree, false);
|
|
mockView.handPanel.rangeClickEvent.emit(redOne, true);
|
|
|
|
assertCollection(Arrays.asList(redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeSelectOnHand() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redOne, new Position(0, 0));
|
|
mockHand.drop(redTwo, new Position(1.5f, 0));
|
|
mockHand.drop(redThree, new Position(0, 1));
|
|
mockHand.drop(redFour, new Position(1, 1));
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redOne, false);
|
|
mockView.handPanel.rangeClickEvent.emit(redThree, true);
|
|
|
|
assertCollection(Arrays.asList(redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeCollectOnHand() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redOne, new Position(0, 0));
|
|
mockHand.drop(redTwo, new Position(1.5f, 0));
|
|
mockHand.drop(redThree, new Position(0, 1));
|
|
mockHand.drop(redFour, new Position(1, 1));
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, false);
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redOne, true);
|
|
mockView.handPanel.rangeClickEvent.emit(redThree, false);
|
|
assertCollection(Arrays.asList(redJoker, redOne, redTwo, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeFailSelectHand() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne));
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockHand.drop(redTwo, new Position(0, 0));
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, false);
|
|
|
|
assertCollection(Arrays.asList(redOne));
|
|
|
|
// Select second stone
|
|
mockView.handPanel.rangeClickEvent.emit(redTwo, false);
|
|
|
|
assertCollection(Arrays.asList(redOne, redTwo));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void rangeFailCollectHand() {
|
|
testControl.startTurn();
|
|
|
|
StoneSet set1 = new StoneSet(Arrays.asList(redOne));
|
|
mockTable.findStoneSet.put(redOne, set1);
|
|
mockHand.drop(redTwo, new Position(0, 0));
|
|
// Select first stone
|
|
mockView.tablePanel.stoneClickEvent.emit(redOne, false);
|
|
assertCollection(Arrays.asList(redOne));
|
|
|
|
// Select second stone
|
|
mockView.handPanel.rangeClickEvent.emit(redTwo, true);
|
|
assertCollection(Arrays.asList(redOne, redTwo));
|
|
}
|
|
|
|
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(mockTimer);
|
|
mockTable.clonedTable = table;
|
|
|
|
mockHand.drop(blueThree, new Position(0, 0));
|
|
mockHand.drop(blueFour, new Position(0, 0));
|
|
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));
|
|
|
|
turnControl.setup(new ITurnControl.TurnInfo(mockRoundState,
|
|
TurnMode.NORMAL_TURN, false), new GameSettings(), mockView);
|
|
turnControl.startTurn();
|
|
|
|
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());
|
|
Pair<StoneSet, StoneSet> newSets = assignNewSets(table, 3);
|
|
assertSame(oldSet2, newSets.getSecond());
|
|
// setcheck
|
|
assertEquals(9, newSets.getFirst().getSize());
|
|
assertions(newSets.getFirst(), Arrays.asList(blueThree, redOne,
|
|
redThree, blueOne, blackOne, redTwo, redFour, blackTwo,
|
|
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());
|
|
newSets = assignNewSets(table, 5);
|
|
// setcheck1
|
|
assertEquals(7, newSets.getFirst().getSize());
|
|
assertions(newSets.getFirst(), Arrays.asList(blueThree, blueOne,
|
|
blackOne, redTwo, redFour, blackTwo, blackThree));
|
|
// setcheck2
|
|
assertEquals(5, newSets.getSecond().getSize());
|
|
assertions(newSets.getSecond(),
|
|
Arrays.asList(redOne, redThree, blueTwo, blackFour, 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(newSets.getSecond());
|
|
|
|
// handcheck
|
|
assertEquals(0, mockHand.getSize());
|
|
// tablecheck
|
|
assertEquals(2, table.getSize());
|
|
newSets = assignNewSets(table, 6);
|
|
// setcheck1
|
|
assertEquals(7, newSets.getFirst().getSize());
|
|
// setcheck2
|
|
assertEquals(6, newSets.getSecond().getSize());
|
|
assertions(newSets.getSecond(), Arrays.asList(blueFour, redOne,
|
|
redThree, blueTwo, blackFour, blackFive));
|
|
}
|
|
|
|
private Pair<StoneSet, StoneSet> assignNewSets(AccessibleTable table, int i) {
|
|
StoneSet set1, set2;
|
|
if (table.getSetArray()[0].getSize() == i) {
|
|
set2 = table.getSetArray()[0];
|
|
set1 = table.getSetArray()[1];
|
|
} else {
|
|
set1 = table.getSetArray()[0];
|
|
set2 = table.getSetArray()[1];
|
|
}
|
|
return new Pair<StoneSet, StoneSet>(set1, set2);
|
|
}
|
|
|
|
private void assertions(StoneSet set, List<Stone> stones) {
|
|
for (int i = 0; i < stones.size(); i++) {
|
|
assertSame(set.get(i), stones.get(i));
|
|
}
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testAddRight() {
|
|
AccessibleTable table = new AccessibleTable();
|
|
mockTable.clonedTable = table;
|
|
HumanTurnControl turnControl = new HumanTurnControl(mockTimer);
|
|
|
|
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));
|
|
|
|
turnControl.setup(new TurnInfo(mockRoundState, TurnMode.NORMAL_TURN,
|
|
false), new GameSettings(), mockView);
|
|
turnControl.startTurn();
|
|
|
|
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());
|
|
|
|
Pair <StoneSet, StoneSet> newSets = assignNewSets(table, 3);
|
|
assertSame(oldSet2, newSets.getSecond());
|
|
// setcheck
|
|
assertEquals(9, newSets.getFirst().getSize());
|
|
assertions(newSets.getFirst(), Arrays.asList(blueOne, blackOne, redTwo, redFour,
|
|
blackTwo, blackThree, blueThree, redOne, 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());
|
|
newSets = assignNewSets(table, 5);
|
|
// setcheck1
|
|
assertEquals(7, newSets.getFirst().getSize());
|
|
assertions(newSets.getFirst(), Arrays.asList(blueOne, blackOne, redTwo, redFour,
|
|
blackTwo, blackThree, blueThree));
|
|
// setcheck2
|
|
assertEquals(5, newSets.getSecond().getSize());
|
|
assertions(newSets.getSecond(),
|
|
Arrays.asList(blueTwo, blackFour, blackFive, redOne, 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(newSets.getSecond());
|
|
|
|
// handcheck
|
|
assertEquals(0, mockHand.getSize());
|
|
// tablecheck
|
|
assertEquals(2, table.getSize());
|
|
newSets = assignNewSets(table, 6);
|
|
// setcheck1
|
|
assertEquals(7, newSets.getFirst().getSize());
|
|
// setcheck2
|
|
assertEquals(6, newSets.getSecond().getSize());
|
|
assertions(newSets.getSecond(), Arrays.asList(blueTwo, blackFour, blackFive,
|
|
redOne, blueFour, redThree));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testAddNewSet() {
|
|
AccessibleTable table = new AccessibleTable();
|
|
mockTable.clonedTable = table;
|
|
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));
|
|
|
|
HumanTurnControl turnControl = new HumanTurnControl(mockTimer);
|
|
turnControl.setup(new TurnInfo(mockRoundState, TurnMode.NORMAL_TURN,
|
|
false), new GameSettings(), mockView);
|
|
turnControl.startTurn();
|
|
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].getSize() == 2) {
|
|
newSet2 = table.getSetArray()[0];
|
|
if (table.getSetArray()[1].getSize() == 4) {
|
|
newSet3 = table.getSetArray()[1];
|
|
newSet1 = table.getSetArray()[2];
|
|
} else {
|
|
newSet3 = table.getSetArray()[2];
|
|
newSet1 = table.getSetArray()[1];
|
|
}
|
|
} else if (table.getSetArray()[0].getSize() == 4) {
|
|
newSet3 = table.getSetArray()[0];
|
|
if (table.getSetArray()[1].getSize() == 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].getSize() == 2) {
|
|
newSet2 = table.getSetArray()[1];
|
|
newSet3 = table.getSetArray()[2];
|
|
} else {
|
|
newSet2 = table.getSetArray()[2];
|
|
newSet3 = table.getSetArray()[1];
|
|
}
|
|
}
|
|
|
|
// setcheck1
|
|
assertEquals(6, newSet1.getSize());
|
|
assertions(newSet1, Arrays.asList(blueOne, blackOne, redTwo, redFour,
|
|
blackTwo, blackThree));
|
|
// setcheck2
|
|
assertEquals(2, newSet2.getSize());
|
|
assertions(newSet2, Arrays.asList(blackFour, blackFive));
|
|
// setcheck1
|
|
assertEquals(4, newSet3.getSize());
|
|
assertions(newSet3, Arrays.asList(blueThree, redOne, redThree, blueTwo));
|
|
|
|
checkTableDisplay(table);
|
|
checkHandDisplay(mockHand);
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testSortByGroups() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redOne, new Position(0, 0));
|
|
mockHand.drop(blueTwo, new Position(0, 0));
|
|
mockHand.drop(redFour, new Position(0, 0));
|
|
mockHand.drop(redThree, new Position(0, 0));
|
|
mockHand.drop(orange10, new Position(0, 0));
|
|
mockHand.drop(blueOne, new Position(0, 0));
|
|
mockHand.drop(blueFour, new Position(0, 0));
|
|
mockHand.drop(blue4a, new Position(0, 0));
|
|
mockHand.drop(blackJoker, new Position(0, 0));
|
|
mockHand.drop(blackFive, 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(), blueOne);
|
|
assertSame(stones.get(1).getFirst(), redOne);
|
|
assertSame(stones.get(2).getFirst(), blueTwo);
|
|
assertSame(stones.get(3).getFirst(), redThree);
|
|
|
|
assertTrue(stones.get(4).getFirst() == blueFour
|
|
|| stones.get(4).getFirst() == blue4a);
|
|
assertTrue(stones.get(5).getFirst() == blueFour
|
|
|| stones.get(5).getFirst() == blue4a);
|
|
|
|
assertSame(stones.get(6).getFirst(), redFour);
|
|
assertSame(stones.get(7).getFirst(), blackFive);
|
|
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(), blackJoker);
|
|
|
|
checkHandDisplay(mockHand);
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testSortByRuns() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redOne, new Position(0, 0));
|
|
mockHand.drop(blueTwo, new Position(0, 0));
|
|
mockHand.drop(redFour, new Position(0, 0));
|
|
mockHand.drop(redThree, new Position(0, 0));
|
|
mockHand.drop(orange10, new Position(0, 0));
|
|
mockHand.drop(blueOne, new Position(0, 0));
|
|
mockHand.drop(blueFour, new Position(0, 0));
|
|
mockHand.drop(blue4a, new Position(0, 0));
|
|
mockHand.drop(blackJoker, new Position(0, 0));
|
|
mockHand.drop(blackFive, 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(), blackFive);
|
|
assertSame(stones.get(1).getFirst(), black10);
|
|
assertSame(stones.get(2).getFirst(), orange10);
|
|
assertSame(stones.get(3).getFirst(), orange13);
|
|
assertSame(stones.get(4).getFirst(), blueOne);
|
|
assertSame(stones.get(5).getFirst(), blueTwo);
|
|
|
|
assertTrue(stones.get(6).getFirst() == blueFour
|
|
|| stones.get(6).getFirst() == blue4a);
|
|
assertTrue(stones.get(7).getFirst() == blueFour
|
|
|| stones.get(7).getFirst() == blue4a);
|
|
|
|
assertSame(stones.get(8).getFirst(), redOne);
|
|
assertSame(stones.get(9).getFirst(), redThree);
|
|
assertSame(stones.get(10).getFirst(), redFour);
|
|
assertSame(stones.get(11).getFirst(), red11);
|
|
assertSame(stones.get(12).getFirst(), blackJoker);
|
|
|
|
checkHandDisplay(mockHand);
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testDropHandValid() {
|
|
testControl.startTurn();
|
|
|
|
mockHand.drop(redJoker, new Position(0, 0));
|
|
mockHand.drop(blackJoker, new Position(1, 0));
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.handPanel.stoneClickEvent.emit(blackJoker, true);
|
|
|
|
mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));
|
|
|
|
assertCollection(new ArrayList<Stone>());
|
|
|
|
Set<Stone> expected = new HashSet<Stone>(Arrays.asList(redJoker,
|
|
blackJoker));
|
|
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();
|
|
|
|
mockHand.drop(redJoker, new Position(0, 0));
|
|
mockHand.drop(black13, new Position(1, 0));
|
|
|
|
mockView.handPanel.stoneClickEvent.emit(redJoker, true);
|
|
mockView.tablePanel.stoneClickEvent.emit(blackJoker, true);
|
|
mockView.handPanel.stoneClickEvent.emit(black13, true);
|
|
|
|
mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));
|
|
|
|
assertCollection(Arrays.asList(blackJoker));
|
|
|
|
Set<Stone> expected = new HashSet<Stone>(Arrays.asList(redJoker,
|
|
black13));
|
|
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 testTableDifference() {
|
|
MockTable oldTable = new MockTable();
|
|
MockTable newTable = new MockTable();
|
|
StoneSet oldSet1 = new StoneSet(
|
|
Arrays.asList(blueOne, redOne, blackOne));
|
|
StoneSet oldSet2 = new StoneSet(blueTwo);
|
|
oldTable.drop(oldSet1, new Position(0, 0));
|
|
oldTable.drop(oldSet2, new Position(0, 0));
|
|
StoneSet newSet1 = new StoneSet(Arrays.asList(blueOne, blueTwo,
|
|
blueFour));
|
|
StoneSet newSet2 = new StoneSet(Arrays.asList(redOne, blackOne,
|
|
blueThree));
|
|
newTable.drop(newSet1, new Position(0, 0));
|
|
newTable.drop(newSet2, new Position(0, 0));
|
|
|
|
Set<Stone> expectedStones = new HashSet<Stone>();
|
|
expectedStones.add(blueThree);
|
|
expectedStones.add(blueFour);
|
|
|
|
Set<Stone> stones = AbstractTurnControl.tableDifference(oldTable,
|
|
newTable);
|
|
|
|
assertTrue(expectedStones.containsAll(stones));
|
|
assertTrue(stones.containsAll(expectedStones));
|
|
}
|
|
|
|
/** */
|
|
@Test
|
|
public void testTableSetDifference() {
|
|
ITable oldTable = new AccessibleTable();
|
|
StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
|
|
blackOne, orangeOne));
|
|
StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blueThree,
|
|
blueFour));
|
|
oldTable.drop(oldSet1, new Position(0, 0));
|
|
oldTable.drop(oldSet2, new Position(0, 0));
|
|
ITable newTable = (Table) oldTable.clone();
|
|
List<StoneSet> newSets = AbstractTurnControl.tableSetDifference(
|
|
oldTable, newTable);
|
|
List<StoneSet> vanishedSets = AbstractTurnControl.tableSetDifference(
|
|
newTable, oldTable);
|
|
|
|
assertTrue(newSets.isEmpty());
|
|
assertTrue(vanishedSets.isEmpty());
|
|
|
|
newTable.pickUp(oldSet2);
|
|
newTable.drop(oldSet2.join(new StoneSet(new Stone(5, BLUE))),
|
|
new Position(0, 0));
|
|
newSets = AbstractTurnControl.tableSetDifference(oldTable, newTable);
|
|
vanishedSets = AbstractTurnControl.tableSetDifference(newTable,
|
|
oldTable);
|
|
|
|
assertFalse(newSets.isEmpty());
|
|
assertFalse(vanishedSets.isEmpty());
|
|
assertEquals(1, newSets.size());
|
|
assertEquals(1, vanishedSets.size());
|
|
|
|
StoneSet oldSet3 = new StoneSet(
|
|
Arrays.asList(redTwo, redThree, redFour));
|
|
ITable newTable2 = (Table) oldTable.clone();
|
|
newTable2.drop(oldSet3, new Position(0, 0));
|
|
newSets = AbstractTurnControl.tableSetDifference(oldTable, newTable2);
|
|
vanishedSets = AbstractTurnControl.tableSetDifference(newTable2,
|
|
oldTable);
|
|
|
|
assertFalse(newSets.isEmpty());
|
|
assertTrue(vanishedSets.isEmpty());
|
|
assertEquals(1, newSets.size());
|
|
}
|
|
|
|
}
|