X-Git-Url: https://troll.desast.re/troll.git/blobdiff_plain/bda92e8fe2871496c68dc2de2d746f8e69c6fd96..e9fb4b60ebdea1a383b0963aa71d0a3ffc1e3822:/src/test/java/TrollTest.java

diff --git a/src/test/java/TrollTest.java b/src/test/java/TrollTest.java
index abbf3c5..7b998b9 100644
--- a/src/test/java/TrollTest.java
+++ b/src/test/java/TrollTest.java
@@ -1,5 +1,6 @@
 import java.util.Properties;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Map;
 import java.io.PrintStream;
 
@@ -10,27 +11,81 @@ 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 {
+    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);
@@ -45,11 +100,11 @@ public class TrollTest {
     }
 
     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());
         }
     }
 
@@ -60,9 +115,9 @@ public class TrollTest {
         }
     }
 
-    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);
@@ -77,16 +132,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<Integer,Integer> scores = gameResult.scores;
         assertEquals("Two scores are reported", scores.size(), 2);