X-Git-Url: https://troll.desast.re/troll.git/blobdiff_plain/bda92e8fe2871496c68dc2de2d746f8e69c6fd96..505d4ac3e3dc4a8f143faed4e6d61f7b9c8e2c33:/src/test/java/TrollTest.java diff --git a/src/test/java/TrollTest.java b/src/test/java/TrollTest.java index abbf3c5..2018014 100644 --- a/src/test/java/TrollTest.java +++ b/src/test/java/TrollTest.java @@ -1,6 +1,10 @@ import java.util.Properties; +import java.util.HashSet; import java.util.List; +import java.util.ListIterator; import java.util.Map; +import java.util.Random; +import java.util.stream.Collectors; import java.io.PrintStream; import static org.junit.Assert.assertEquals; @@ -10,27 +14,174 @@ import org.junit.Test; import com.codingame.gameengine.runner.MultiplayerGameRunner; import com.codingame.gameengine.runner.dto.*; -public class TrollTest { - @Test - public void test() { +public class TrollTest implements Cloneable { + int leagueLevel = 1; // @#$%^&* league parameter is *global* despite API! + Long seed; + Integer roadLength; + Integer initialStones; + 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; } + TrollTest setRoadLength(int l) { roadLength = l; return this; } + TrollTest setInitialStones(int s) { initialStones = s; return this; } + + GameResult runGame(String left, String right) { MultiplayerGameRunner gameRunner = new MultiplayerGameRunner(); + gameRunner.setLeagueLevel(leagueLevel); + if (seed != null) gameRunner.setSeed(seed); else gameRunner.setSeed(0l); Properties gameParameters = new Properties(); - gameParameters.setProperty("roadLength", "6"); - gameParameters.setProperty("initialStones", "15"); gameRunner.setGameParameters(gameParameters); - gameRunner.setSeed(0l); - gameRunner.setLeagueLevel(1); + if (roadLength != null) + gameParameters.setProperty("roadLength", roadLength.toString()); + if (initialStones != null) + gameParameters.setProperty("initialStones", initialStones.toString()); + + 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)); + } - gameRunner.addAgent(agentOne); - gameRunner.addAgent(agentOne); + @Test + public void simpleGames() { + // wins by direct reach, no fastforward + assertWinLose(agentTwo, agentOne); + + // win by fastforward after loser exhaustion + assertWinLose(agentOne, agentAllIn); + + // win despite fastforward after winner exhaustion + // (harder to construct :-D ) + assertWinLose(agent(1,2,2,2,8), agent(3,1,1,1,8)); + } - assertIsDraw(gameRunner.simulate()); + @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) + .setRoadLength(6).setInitialStones(15) + .assertWinLose(agentCheat, agentTwo); + branch().setLeague(2).setSeed(1) + .setRoadLength(6).setInitialStones(15) + .assertWinLose(agentTwo, agentCheat); + } + + static private class GameMap { + int roadLength; + int initialStones; + @Override public boolean equals(Object gm) { + if (gm instanceof GameMap) { + return roadLength == ((GameMap) gm).roadLength + && initialStones == ((GameMap) gm).initialStones; + } + else return false; + } + @Override public int hashCode() { + return roadLength << 16 | initialStones; + } + } + + @Test + public void maps() { + TrollTest test = branch(); + + // league 1, expect a single map + for (long s = 0; s < 16; s++) { + test.setSeed(s); + GameMap map = test.measureMap(); + assertEquals("Level 1 roadLength", 6, map.roadLength); + assertEquals("Level 1 initialStones", 15, map.initialStones); + } + + // league 2, expect one of four maps + test.setLeague(2); + HashSet maps = new HashSet(); + Random r = new Random(); + for (int i = 0; i < 16; i++) { + test.setSeed(r.nextLong()); + GameMap map = test.measureMap(); + maps.add(map); + } + assertEquals("Level 2 has four maps", 4, maps.size()); + + // league 3, maps simply have constraints + test.setLeague(3); + for (long s = 0; s < 16; s++) { + test.setSeed(s); + GameMap map = test.measureMap(); + assertTrue("Level 3 road length is at least 6", + map.roadLength >= 6); + assertTrue("Level 3 road length is at most 14", + map.roadLength <= 14); + assertTrue("Level 3 road length is even", + map.roadLength % 2 == 0); + assertTrue("Level 3 stones is at least 15", + map.initialStones >= 15); + assertTrue("Level 3 stones is at most 50", + map.initialStones <= 50); + } + } + + /* + * There's currently no way to extract the parameters (and verify + * them!) from a game. So for now we measure it from other + * traces. + */ + private GameMap measureMap() { + GameMap result = new GameMap(); + + // roadLength is twice the number of moves a troll takes + // before the end of the game in a + // position-independent-strategy game. + GameResult game = runGame(agentOne, agentTwo); + result.roadLength = 2 * game.summaries.stream() + .filter(s -> s.contains("walks")) + .collect(Collectors.counting()).intValue(); + + // initialStones is the number of times a troll stands still + // in a one-stone-throw draw. + game = runGame(agentOne, agentOne); + result.initialStones = game.summaries.stream() + .filter(s -> s.contains("still")) + .collect(Collectors.counting()).intValue(); + + return result; } // 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 agentAllIn = "yes 15"; + 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); @@ -45,11 +196,11 @@ public class TrollTest { } static void dumpList(PrintStream p, String tag, List 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()); } } @@ -60,9 +211,9 @@ public class TrollTest { } } - static void dumpGeneric(PrintStream p, V v) { + static void dumpGeneric(PrintStream p, E v) { if (v instanceof List) { - dumpList(p, null, (List) v); + dumpList(p, null, (List) v); } else { p.println(v); @@ -77,16 +228,53 @@ public class TrollTest { 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 scores = gameResult.scores; assertEquals("Two scores are reported", scores.size(), 2);