ambidextrous/gemp-lotr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added JUnit test.

Browse Source
This commit is contained in:
marcins78@gmail.com
2012-07-04 10:09:48 +00:00
parent 7809544167
commit b37519b6e4
4 changed files with 180 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/hall/HallServer.java
View File

@@ -63,7 +63,7 @@ public class HallServer extends AbstractServer {
_runningTournaments.addAll(tournamentService.getLiveTournaments());
_tournamentQueues.put("fotr_queue", new SingleEliminationRecurringQueue(0, "fotr_block",
new CollectionType("default", "All cards"), "fotrQueue-", "Fellowship Block", 2,
new CollectionType("default", "All cards"), "fotrQueue-", "Fellowship Block 4-man", 2,
tournamentService));
}
@@ -444,7 +444,7 @@ public class HallServer extends AbstractServer {
}
for (Tournament runningTournament : _runningTournaments) {
if (runningTournament.isPlayerCompeting(playerId))
if (runningTournament.isPlayerInCompetition(playerId))
return true;
}

51
gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/AbstractTournament.java
View File

@@ -22,9 +22,9 @@ public abstract class AbstractTournament implements Tournament {
private TournamentTask _nextTask;
private HashSet<String> _allPlayers;
private HashMap<String, LotroDeck> _playerDecks;
protected HashSet<String> _playersInContention;
private Set<String> _allPlayers;
private Map<String, LotroDeck> _playerDecks;
protected Set<String> _playersInContention;
private Set<String> _droppedPlayers = new HashSet<String>();
private Map<String, Integer> _playerByes = new HashMap<String, Integer>();
@@ -33,6 +33,7 @@ public abstract class AbstractTournament implements Tournament {
private List<PlayerStanding> _playerStandings;
protected ReadWriteLock _lock = new ReentrantReadWriteLock();
private long _waitForPairingsTime = 1000 * 60 * 2;
public AbstractTournament(TournamentService tournamentService, String tournamentId, String format,
CollectionType collectionType, String tournamentName) {
@@ -84,6 +85,10 @@ public abstract class AbstractTournament implements Tournament {
}
}
public void setWaitForPairingsTime(long waitForPairingsTime) {
_waitForPairingsTime = waitForPairingsTime;
}
@Override
public String getTournamentId() {
return _tournamentId;
@@ -116,7 +121,7 @@ public abstract class AbstractTournament implements Tournament {
_nextTask = new PairPlayers();
}
}
if (_nextTask != null && _nextTask.getExecuteAfter() < System.currentTimeMillis()) {
if (_nextTask != null && _nextTask.getExecuteAfter() <= System.currentTimeMillis()) {
TournamentTask task = _nextTask;
_nextTask = null;
task.executeTask(tournamentCallback);
@@ -187,10 +192,10 @@ public abstract class AbstractTournament implements Tournament {
}
@Override
public boolean isPlayerCompeting(String player) {
public boolean isPlayerInCompetition(String player) {
_lock.readLock().lock();
try {
return _playersInContention.contains(player);
return _playersInContention.contains(player) && !_droppedPlayers.contains(player) && !isFinished();
} finally {
_lock.readLock().unlock();
}
@@ -220,15 +225,7 @@ public abstract class AbstractTournament implements Tournament {
@Override
public void executeTask(TournamentCallback tournamentCallback) {
tournamentCallback.broadcastMessage("Tournament " + getTournamentName() + " is starting");
_playersInContention.removeAll(_droppedPlayers);
_droppedPlayers.clear();
if (isFinished()) {
finishTournament(tournamentCallback);
} else {
_currentRound++;
pairPlayers(tournamentCallback);
}
doPairing(tournamentCallback);
}
@Override
@@ -238,19 +235,11 @@ public abstract class AbstractTournament implements Tournament {
}
private class PairPlayers implements TournamentTask {
private long _taskStart = System.currentTimeMillis() + 1000 * 60 * 2;
private long _taskStart = System.currentTimeMillis() + _waitForPairingsTime;
@Override
public void executeTask(TournamentCallback tournamentCallback) {
_playersInContention.removeAll(_droppedPlayers);
_droppedPlayers.clear();
if (isFinished()) {
finishTournament(tournamentCallback);
} else {
_currentRound++;
pairPlayers(tournamentCallback);
}
doPairing(tournamentCallback);
}
@Override
@@ -259,6 +248,18 @@ public abstract class AbstractTournament implements Tournament {
}
}
private void doPairing(TournamentCallback tournamentCallback) {
_playersInContention.removeAll(_droppedPlayers);
_droppedPlayers.clear();
if (isFinished()) {
finishTournament(tournamentCallback);
} else {
_currentRound++;
pairPlayers(tournamentCallback);
}
}
protected abstract void pairPlayers(TournamentCallback tournamentCallback);
protected void pairNewGame(TournamentCallback tournamentCallback, String playerOne, String playerTwo) {

2
gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/Tournament.java
View File

@@ -26,5 +26,5 @@ public interface Tournament {
public boolean isFinished();
public boolean isPlayerCompeting(String player);
public boolean isPlayerInCompetition(String player);
}

151
gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationTournamentTest.java Normal file
View File

@@ -0,0 +1,151 @@
package com.gempukku.lotro.tournament;
import com.gempukku.lotro.game.LotroGameParticipant;
import com.gempukku.lotro.logic.vo.LotroDeck;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import org.mockito.internal.verification.Times;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.junit.Assert.*;
public class SingleEliminationTournamentTest {
@Test
public void simpleTest() {
TournamentService service = Mockito.mock(TournamentService.class);
SingleEliminationTournament tournament = new SingleEliminationTournament(service, "tid", "fotr_block,default,All cards,Tournament name");
assertEquals("fotr_block", tournament.getFormat());
assertEquals("default", tournament.getCollectionType().getCode());
assertEquals("All cards", tournament.getCollectionType().getFullName());
assertEquals("Tournament name", tournament.getTournamentName());
}
@Test
public void testPairing() {
Map<String, LotroDeck> players = new HashMap<String, LotroDeck>();
players.put("p1", new LotroDeck("d1"));
players.put("p2", new LotroDeck("d2"));
TournamentService service = Mockito.mock(TournamentService.class);
Mockito.when(service.getPlayers("tid")).thenReturn(players);
SingleEliminationTournament tournament = new SingleEliminationTournament(service, "tid", "fotr_block,default,All cards,Tournament name");
TournamentCallback tournamentCallback = Mockito.mock(TournamentCallback.class);
tournament.advanceTournament(tournamentCallback);
Mockito.verify(tournamentCallback, new Times(1)).createGame(Mockito.<LotroGameParticipant>any(), Mockito.<LotroGameParticipant>any());
assertTrue(tournament.isPlayerInCompetition("p1"));
assertTrue(tournament.isPlayerInCompetition("p2"));
assertFalse(tournament.isPlayerInCompetition("p3"));
tournament.dropPlayer("p2");
assertFalse(tournament.isPlayerInCompetition("p2"));
tournament.reportGameFinished(tournamentCallback, "p1", "p2");
tournament.advanceTournament(tournamentCallback);
assertTrue(tournament.isFinished());
assertFalse(tournament.isPlayerInCompetition("p1"));
assertFalse(tournament.isPlayerInCompetition("p2"));
}
@Test
public void testLongerTournament() {
Map<String, LotroDeck> players = new HashMap<String, LotroDeck>();
players.put("p1", new LotroDeck("d1"));
players.put("p2", new LotroDeck("d2"));
players.put("p3", new LotroDeck("d3"));
players.put("p4", new LotroDeck("d4"));
TournamentService service = Mockito.mock(TournamentService.class);
Mockito.when(service.getPlayers("tid")).thenReturn(players);
SingleEliminationTournament tournament = new SingleEliminationTournament(service, "tid", "fotr_block,default,All cards,Tournament name");
tournament.setWaitForPairingsTime(0);
assertEquals(0, tournament.getCurrentRound());
TournamentCallback tournamentCallback = Mockito.mock(TournamentCallback.class);
tournament.advanceTournament(tournamentCallback);
assertEquals(1, tournament.getCurrentRound());
ArgumentCaptor<LotroGameParticipant> playerOne = ArgumentCaptor.forClass(LotroGameParticipant.class);
ArgumentCaptor<LotroGameParticipant> playerTwo = ArgumentCaptor.forClass(LotroGameParticipant.class);
Mockito.verify(tournamentCallback, new Times(2)).createGame(playerOne.capture(), playerTwo.capture());
List<LotroGameParticipant> playerOnes = playerOne.getAllValues();
List<LotroGameParticipant> playerTwos = playerTwo.getAllValues();
List<String> oneNames = extractNames(playerOnes);
List<String> twoNames = extractNames(playerTwos);
assertTrue(oneNames.contains("p1") || twoNames.contains("p1"));
assertTrue(oneNames.contains("p2") || twoNames.contains("p2"));
assertTrue(oneNames.contains("p3") || twoNames.contains("p3"));
assertTrue(oneNames.contains("p4") || twoNames.contains("p4"));
assertTrue(tournament.isPlayerInCompetition("p1"));
assertTrue(tournament.isPlayerInCompetition("p2"));
assertTrue(tournament.isPlayerInCompetition("p3"));
assertTrue(tournament.isPlayerInCompetition("p4"));
String playerAgainstP1 = getPlayerPlayingAgainst(oneNames, twoNames, "p1");
String secondWinner;
tournament.reportGameFinished(tournamentCallback, "p1", playerAgainstP1);
if (playerAgainstP1.equals("p2")) {
secondWinner = "p3";
tournament.reportGameFinished(tournamentCallback, "p3", "p4");
} else if (playerAgainstP1.equals("p3")) {
secondWinner = "p2";
tournament.reportGameFinished(tournamentCallback, "p2", "p4");
} else {
secondWinner = "p2";
tournament.reportGameFinished(tournamentCallback, "p2", "p3");
}
assertEquals(1, tournament.getCurrentRound());
tournamentCallback = Mockito.mock(TournamentCallback.class);
tournament.advanceTournament(tournamentCallback);
assertEquals(2, tournament.getCurrentRound());
ArgumentCaptor<LotroGameParticipant> playerOne2 = ArgumentCaptor.forClass(LotroGameParticipant.class);
ArgumentCaptor<LotroGameParticipant> playerTwo2 = ArgumentCaptor.forClass(LotroGameParticipant.class);
Mockito.verify(tournamentCallback, new Times(1)).createGame(playerOne2.capture(), playerTwo2.capture());
assertTrue(oneNames.contains("p1") || twoNames.contains("p1"));
assertTrue(oneNames.contains(secondWinner) || twoNames.contains(secondWinner));
tournament.reportGameFinished(tournamentCallback, "p1", secondWinner);
assertTrue(tournament.isFinished());
assertFalse(tournament.isPlayerInCompetition("p1"));
assertFalse(tournament.isPlayerInCompetition("p2"));
assertFalse(tournament.isPlayerInCompetition("p3"));
assertFalse(tournament.isPlayerInCompetition("p4"));
}
private String getPlayerPlayingAgainst(List<String> oneNames, List<String> twoNames, String player) {
String playerAgainstP1;
if (oneNames.contains(player))
playerAgainstP1 = twoNames.get(oneNames.indexOf(player));
else
playerAgainstP1 = oneNames.get(twoNames.indexOf(player));
return playerAgainstP1;
}
private List<String> extractNames(List<LotroGameParticipant> playerOnes) {
List<String> result = new ArrayList<String>();
for (LotroGameParticipant playerOne : playerOnes) {
result.add(playerOne.getPlayerId());
}
return result;
}
}