More testing. This code cleanup session supported by @Zorg1.

[troll.git] / src / test / java / TrollTest.java

diff --git a/src/test/java/TrollTest.java b/src/test/java/TrollTest.java
index abbf3c5..e8dff3f 100644 (file)
--- 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.Properties;
 import java.util.List;

+import java.util.ListIterator;

 import java.util.Map;
 import java.io.PrintStream;
 
 import java.util.Map;
 import java.io.PrintStream;
 


@@ -11,8 +12,7 @@ import com.codingame.gameengine.runner.MultiplayerGameRunner;
 import com.codingame.gameengine.runner.dto.*;
 
 public class TrollTest {
 import com.codingame.gameengine.runner.dto.*;
 
 public class TrollTest {

-    @Test
-    public void test() {
+    static GameResult runGame(String left, String right) {

         MultiplayerGameRunner gameRunner = new MultiplayerGameRunner();
         Properties gameParameters = new Properties();
         gameParameters.setProperty("roadLength", "6");
         MultiplayerGameRunner gameRunner = new MultiplayerGameRunner();
         Properties gameParameters = new Properties();
         gameParameters.setProperty("roadLength", "6");


@@ -21,16 +21,52 @@ public class TrollTest {
         gameRunner.setSeed(0l);
         gameRunner.setLeagueLevel(1);
 
         gameRunner.setSeed(0l);
         gameRunner.setLeagueLevel(1);
 

-        gameRunner.addAgent(agentOne);
-        gameRunner.addAgent(agentOne);
+        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);
+
+        // 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));

     }
 
     // great thanks to @dbdr for the intense moral support leading to
     // the following:
     static String agentOne = "yes 1";
     static String agentTwo = "yes 2";
     }
 
     // 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 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 void dumpGameResult(PrintStream p, GameResult gameResult) {
         for (AgentDto agent : gameResult.agents) dumpAgent(p, agent);


@@ -45,11 +81,11 @@ public class TrollTest {
     }
 
     static <V> void dumpList(PrintStream p, String tag, List<V> list) {
     }
 
     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 + " ");
             if (tag != null) p.print(tag + " ");

-            p.print(i + ": ");
-            dumpGeneric(p, a[i]);
+            p.print(i.nextIndex() + ": ");
+            dumpGeneric(p, i.next());

         }
     }
 
         }
     }
 


@@ -60,9 +96,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) {
         if (v instanceof List) {

-            dumpList(p, null, (List) v);
+            dumpList(p, null, (List<?>) v);

         }
         else {
             p.println(v);
         }
         else {
             p.println(v);


@@ -77,16 +113,45 @@ public class TrollTest {
         p.println("[agent] " + agent.agentId + ": " + agent.avatar + " " + agent.index + " " + agent.name);
     }
 
         p.println("[agent] " + agent.agentId + ": " + agent.avatar + " " + agent.index + " " + agent.name);
     }
 

+    static void assertWinLose(String winner, String loser) {
+        assertLeftWin(runGame(winner, loser));
+        assertRightWin(runGame(loser, winner));
+    }
+
+    static void assertLeftWin(GameResult gameResult) {
+        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);
+    }
+
+    static void assertRightWin(GameResult gameResult) {
+        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);
+    }
+

     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);
     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);
     }
 
         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);
     static int[] assertTwoScores(GameResult gameResult) {
         Map<Integer,Integer> scores = gameResult.scores;
         assertEquals("Two scores are reported", scores.size(), 2);