From b37519b6e466ed843ccb0ed6a7b3970256d7be2b Mon Sep 17 00:00:00 2001 From: "marcins78@gmail.com" Date: Wed, 4 Jul 2012 10:09:48 +0000 Subject: [PATCH] Added JUnit test. --- .../com/gempukku/lotro/hall/HallServer.java | 4 +- .../lotro/tournament/AbstractTournament.java | 51 +++--- .../gempukku/lotro/tournament/Tournament.java | 2 +- .../SingleEliminationTournamentTest.java | 151 ++++++++++++++++++ 4 files changed, 180 insertions(+), 28 deletions(-) create mode 100644 gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationTournamentTest.java diff --git a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/hall/HallServer.java b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/hall/HallServer.java index 4c043deda..5773d5609 100644 --- a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/hall/HallServer.java +++ b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/hall/HallServer.java @@ -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; } diff --git a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/AbstractTournament.java b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/AbstractTournament.java index 731e37956..cbcdd8a5d 100644 --- a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/AbstractTournament.java +++ b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/AbstractTournament.java @@ -22,9 +22,9 @@ public abstract class AbstractTournament implements Tournament { private TournamentTask _nextTask; - private HashSet _allPlayers; - private HashMap _playerDecks; - protected HashSet _playersInContention; + private Set _allPlayers; + private Map _playerDecks; + protected Set _playersInContention; private Set _droppedPlayers = new HashSet(); private Map _playerByes = new HashMap(); @@ -33,6 +33,7 @@ public abstract class AbstractTournament implements Tournament { private List _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) { diff --git a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/Tournament.java b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/Tournament.java index 4efde8e34..fd4dca6f6 100644 --- a/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/Tournament.java +++ b/gemp-lotr/gemp-lotr-server/src/main/java/com/gempukku/lotro/tournament/Tournament.java @@ -26,5 +26,5 @@ public interface Tournament { public boolean isFinished(); - public boolean isPlayerCompeting(String player); + public boolean isPlayerInCompetition(String player); } diff --git a/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationTournamentTest.java b/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationTournamentTest.java new file mode 100644 index 000000000..4594cb2f7 --- /dev/null +++ b/gemp-lotr/gemp-lotr-server/src/test/java/com/gempukku/lotro/tournament/SingleEliminationTournamentTest.java @@ -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 players = new HashMap(); + 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.any(), Mockito.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 players = new HashMap(); + 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 playerOne = ArgumentCaptor.forClass(LotroGameParticipant.class); + ArgumentCaptor playerTwo = ArgumentCaptor.forClass(LotroGameParticipant.class); + Mockito.verify(tournamentCallback, new Times(2)).createGame(playerOne.capture(), playerTwo.capture()); + + List playerOnes = playerOne.getAllValues(); + List playerTwos = playerTwo.getAllValues(); + + List oneNames = extractNames(playerOnes); + List 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 playerOne2 = ArgumentCaptor.forClass(LotroGameParticipant.class); + ArgumentCaptor 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 oneNames, List 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 extractNames(List playerOnes) { + List result = new ArrayList(); + for (LotroGameParticipant playerOne : playerOnes) { + result.add(playerOne.getPlayerId()); + } + return result; + } +}