import java.util.Properties;
import java.util.List;
+import java.util.ListIterator;
import java.util.Map;
import java.io.PrintStream;
import com.codingame.gameengine.runner.MultiplayerGameRunner;
import com.codingame.gameengine.runner.dto.*;
-public class TrollTest {
- @Test
- public void test() {
+public class TrollTest implements Cloneable {
+ Integer leagueLevel;
+ Long seed;
+ TrollTest branch() {
+ try { return (TrollTest) clone(); }
+ catch (CloneNotSupportedException e) { throw new InternalError(e); }
+ }
+ TrollTest setLeague(int league) { leagueLevel = league; return this; }
+ TrollTest setSeed(long seed) { this.seed = seed; return this; }
+
+ GameResult runGame(String left, String right) {
MultiplayerGameRunner gameRunner = new MultiplayerGameRunner();
Properties gameParameters = new Properties();
gameParameters.setProperty("roadLength", "6");
gameParameters.setProperty("initialStones", "15");
gameRunner.setGameParameters(gameParameters);
- gameRunner.setSeed(0l);
- gameRunner.setLeagueLevel(1);
+ if (seed != null) gameRunner.setSeed(seed); else gameRunner.setSeed(0l);
+ if (leagueLevel != null) gameRunner.setLeagueLevel(leagueLevel);
+
+ gameRunner.addAgent(left);
+ gameRunner.addAgent(right);
+
+ return gameRunner.simulate();
+ }
+
+ @Test
+ public void drawGame() {
+ assertIsDraw(runGame(agentOne, agentOne));
+ }
+
+ @Test
+ public void defeatGames() {
+ assertIsDefeat(runGame(agentCrash, agentCrash));
+ assertIsDefeat(runGame(agentGarbage, agentGarbage));
+ }
+
+ @Test
+ public void simpleGames() {
+ // wins by direct reach, no fastforward
+ assertWinLose(agentTwo, agentOne);
- gameRunner.addAgent(agentOne);
- gameRunner.addAgent(agentOne);
+ // win by fastforward after loser exhaustion
+ assertWinLose(agentOne, "yes 15");
- assertIsDraw(gameRunner.simulate());
+ // win despite fastforward after winner exhaustion
+ // (harder to construct :-D )
+ assertWinLose(agent(1,2,2,2,8), agent(3,1,1,1,8));
+ }
+
+ @Test
+ public void cheatingGames() {
+ // win by cheating (works in league 1, which is the default)
+ assertWinLose(agentCheat, agentTwo);
+
+ // league 2 randomizes: we should be able to get a win and a loss
+ branch().setLeague(2).setSeed(0).assertWinLose(agentCheat, agentTwo);
+ branch().setLeague(2).setSeed(1).assertWinLose(agentTwo, agentCheat);
}
// great thanks to @dbdr for the intense moral support leading to
// the following:
static String agentOne = "yes 1";
static String agentTwo = "yes 2";
+ static String agentCrash = "false";
+ static String agentGarbage = "yes this_is_assuredly_not_an_int";
+ static String agentCheat = agent(-100,25,25,25,25);
+
+ static String agent(int... tosses) {
+ String cmd = "echo -e ";
+ for (int i = 0; i < tosses.length; i++) {
+ if (i > 0) cmd += "\\n";
+ cmd += tosses[i];
+ }
+ return cmd;
+ }
static void dumpGameResult(PrintStream p, GameResult gameResult) {
for (AgentDto agent : gameResult.agents) dumpAgent(p, agent);
}
static <V> void dumpList(PrintStream p, String tag, List<V> list) {
- V[] a = (V[]) list.toArray();
- for (int i = 0; i < a.length; i++) {
+ ListIterator i = list.listIterator();
+ while (i.hasNext()) {
if (tag != null) p.print(tag + " ");
- p.print(i + ": ");
- dumpGeneric(p, a[i]);
+ p.print(i.nextIndex() + ": ");
+ dumpGeneric(p, i.next());
}
}
}
}
- static <V> void dumpGeneric(PrintStream p, V v) {
+ static <E,V> void dumpGeneric(PrintStream p, E v) {
if (v instanceof List) {
- dumpList(p, null, (List) v);
+ dumpList(p, null, (List<?>) v);
}
else {
p.println(v);
p.println("[agent] " + agent.agentId + ": " + agent.avatar + " " + agent.index + " " + agent.name);
}
+ void assertWinLose(String winner, String loser) {
+ assertLeftWin(runGame(winner, loser));
+ assertRightWin(runGame(loser, winner));
+ }
+
+ static void assertLeftWin(GameResult gameResult) {
+ assertLeftWin(gameResult, false);
+ }
+ static void assertLeftWin(GameResult gameResult, boolean strict) {
+ int[] scores = assertTwoScores(gameResult);
+ if (scores == null) return;
+
+ int s1 = scores[0], s2 = scores[1];
+ assertTrue("Left player has higher score than right player", s1 > s2);
+ if (strict) assertTrue("Right player isn't disqualified", s2 >= 0);
+ }
+
+ static void assertRightWin(GameResult gameResult) {
+ assertRightWin(gameResult, false);
+ }
+ static void assertRightWin(GameResult gameResult, boolean strict) {
+ int[] scores = assertTwoScores(gameResult);
+ if (scores == null) return;
+
+ int s1 = scores[0], s2 = scores[1];
+ assertTrue("Right player has higher score than right player", s2 > s1);
+ if (strict) assertTrue("Left player isn't disqualified", s1 >= 0);
+ }
+
static void assertIsDraw(GameResult gameResult) {
int[] scores = assertTwoScores(gameResult);
if (scores == null) return;
int s1 = scores[0], s2 = scores[1];
assertEquals("Player scores are equal", s1, s2);
- dumpGameResult(System.err, gameResult);
assertTrue("Player scores are non-negative", s1 >= 0);
}
+ static void assertIsDefeat(GameResult gameResult) {
+ int[] scores = assertTwoScores(gameResult);
+ if (scores == null) return;
+
+ int s1 = scores[0], s2 = scores[1];
+ assertTrue("First player score is negative", s1 < 0);
+ assertTrue("Second player score is negative", s2 < 0);
+ }
+
static int[] assertTwoScores(GameResult gameResult) {
Map<Integer,Integer> scores = gameResult.scores;
assertEquals("Two scores are reported", scores.size(), 2);
Ça trolle… / troll.git / blobdiff