Digest CH-005: prove survivor death delivery

Author: flemming-n-larsen

.clue/id-ledger.yaml

@@ -8,9 +8,9 @@ counters:
     CH: "5"
     CRIT: "8"
     DES: "8"
-    EVT: "13"
+    EVT: "14"
     G: "2"
-    IDR: "3"
+    IDR: "4"
     OQ: "2"
     P: "1"
     PDR: "2"
@@ -330,7 +330,7 @@ entries:
       component: "6"
     - id: EVT-007
       kind: numeric
-      state: live
+      state: retired
       prefix: EVT
       component: "7"
     - id: EVT-008
@@ -363,6 +363,11 @@ entries:
       state: live
       prefix: EVT
       component: "13"
+    - id: EVT-014
+      kind: numeric
+      state: live
+      prefix: EVT
+      component: "14"
     - id: G-001
       kind: numeric
       state: live
@@ -388,6 +393,11 @@ entries:
       state: live
       prefix: IDR
       component: "3"
+    - id: IDR-004
+      kind: numeric
+      state: live
+      prefix: IDR
+      component: "4"
     - id: OQ-001
       kind: numeric
       state: live

changes/CH-005-death-event-evidence-boundary/open-questions.md

@@ -889,6 +889,8 @@ def parse_args():
     conf.add_argument("--conformance", metavar="JAR",
                       help="run one robot jar on one engine and print the result, "
                            "including each participant's console output, as JSON")
+    conf.add_argument("--conformance-source", type=Path,
+                      help="compile this bridge-owned robot source against classic before running it")
     conf.add_argument("--engine", choices=("rc", "tr"), default="rc",
                       help="which engine --conformance drives")
     conf.add_argument("--robot-class",
@@ -1053,6 +1055,24 @@ def compile_trace_robot(opts):
     return out_dir, None
 
 
+def compile_conformance_robot(opts, source: Path):
+    """Compiles a bridge-owned conformance probe against the classic API."""
+    out_dir = WORK_DIR / "conformance-probe-classes"
+    clean_dir(out_dir)
+    if not source.exists():
+        return None, f"conformance probe source not found: {source}"
+
+    classpath = str(Path(opts.robocode_home) / "libs" / "*")
+    cmd = [javac_beside(opts.rc_java_exe), "-cp", classpath, "-d", str(out_dir), str(source)]
+    try:
+        completed = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
+    except (OSError, subprocess.SubprocessError) as e:
+        return None, f"could not compile conformance probe: {e}"
+    if completed.returncode != 0:
+        return None, f"conformance probe did not compile:\n{completed.stdout}\n{completed.stderr}"
+    return out_dir, None
+
+
 def javac_beside(java_exe):
     """The javac that ships next to a given java executable.
 
@@ -1213,7 +1233,17 @@ def run_conformance(opts):
     if opts.participants is not None:
         setup["participants"] = opts.participants
 
-    if jar.is_dir():
+    if opts.conformance_source:
+        class_dir, error = compile_conformance_robot(opts, opts.conformance_source)
+        if error:
+            print(json.dumps({"ok": False, "fatal": error}))
+            return 2
+        packaged, error = package_test_robot_jar(class_dir, classname, WORK_DIR / "conformance")
+        if error:
+            print(json.dumps({"ok": False, "fatal": error}))
+            return 2
+        jar, version = packaged, "1.0"
+    elif jar.is_dir():
         # Package the one robot under test, for both engines.
         #
         # The bridge side needs a real robot jar because the wrapper finds robots by their

changes/CH-005-death-event-evidence-boundary/proposal.md

@@ -0,0 +1,35 @@
+package conformance.probes;
+
+import robocode.DeathEvent;
+import robocode.Robot;
+import robocode.RobotDeathEvent;
+import robocode.ScannedRobotEvent;
+
+/** A two-instance probe that reports its own and another robot's death handlers. */
+public class DeathEventProbe extends Robot {
+
+    @Override
+    public void run() {
+        while (true) {
+            ahead(100);
+            turnGunRight(360);
+            back(100);
+            turnGunRight(360);
+        }
+    }
+
+    @Override
+    public void onScannedRobot(ScannedRobotEvent event) {
+        fire(2);
+    }
+
+    @Override
+    public void onRobotDeath(RobotDeathEvent event) {
+        out.println("OtherDeath!");
+    }
+
+    @Override
+    public void onDeath(DeathEvent event) {
+        out.println("OwnDeath!");
+    }
+}

changes/CH-005-death-event-evidence-boundary/tasks.md

@@ -39,6 +39,11 @@ private ConformanceHarness(String python, Path robocodeHome, Path testRobotClass
         this.rounds = rounds;
     }
 
+    /** Repository root, for bridge-owned probe sources passed to the Python harness. */
+    static Path repoRoot() {
+        return REPO_ROOT;
+    }
+
     /** The number of rounds every battle this harness runs is configured for. */
     int rounds() {
         return rounds;
@@ -89,7 +94,7 @@ static String missingEnvironment() {
      *
      * @param robotClass fully qualified, e.g. {@code tested.robots.InteruptibleEvent}
      */
-    BattleOutcome run(Engine engine, String robotClass) {
+    BattleOutcome run(Engine engine, String robotClass, Path source) {
         List<String> command = new ArrayList<>(List.of(
                 python,
                 HARNESS.toString(),
@@ -98,6 +103,10 @@ BattleOutcome run(Engine engine, String robotClass) {
                 "--engine", engine.harnessName(),
                 "--rounds", String.valueOf(rounds),
                 "--robocode-home", robocodeHome.toString()));
+        if (source != null) {
+            command.add("--conformance-source");
+            command.add(source.toString());
+        }
 
         try {
             Process process = new ProcessBuilder(command)

compat-test/compat_test.py

@@ -4,6 +4,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.nio.file.Path;
 
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
@@ -43,8 +44,13 @@ interface Expectation {
      * Runs the robot on both engines and applies the same expectation to each.
      */
     void assertOnBothEngines(String robotClass, Expectation expectation) {
+        assertOnBothEngines(robotClass, null, expectation);
+    }
+
+    /** Runs a locally held probe source on both engines after compiling it against classic. */
+    void assertOnBothEngines(String robotClass, Path source, Expectation expectation) {
         for (Engine engine : Engine.values()) {
-            BattleOutcome outcome = outcomeFor(engine, robotClass);
+            BattleOutcome outcome = outcomeFor(engine, robotClass, source);
             assertTrue(outcome.completed(),
                     () -> "the battle did not complete on " + engine + " (" + outcome.summary() + ")");
             expectation.check(outcome, engine);
@@ -59,8 +65,12 @@ void assertOnBothEngines(String robotClass, Expectation expectation) {
      * reason that has nothing to do with what it claims to check.
      */
     BattleOutcome outcomeFor(Engine engine, String robotClass) {
+        return outcomeFor(engine, robotClass, null);
+    }
+
+    private BattleOutcome outcomeFor(Engine engine, String robotClass, Path source) {
         return ran.computeIfAbsent(engine.name() + " " + robotClass,
-                key -> harness.run(engine, robotClass));
+                key -> harness.run(engine, robotClass, source));
     }
 
     /** The number of rounds every battle in this run is configured for. */

compat-test/conformance-robots/conformance/probes/DeathEventProbe.java

@@ -0,0 +1,26 @@
+package dev.robocode.tankroyale.bridge.conformance;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/** Acceptance evidence for EVT-014 — a survivor receives another robot's death. */
+class RobotDeathEventsConformanceTest extends ConformanceTestBase {
+
+    private static final String ROBOT = "conformance.probes.DeathEventProbe";
+    private static final Path SOURCE = ConformanceHarness.repoRoot().resolve(Path.of("compat-test",
+            "conformance-robots", "conformance", "probes", "DeathEventProbe.java"));
+    private static final String OTHER_DEATH = "OtherDeath!";
+
+    @Test
+    @DisplayName("EVT-014: a surviving robot reports another robot's death on both engines")
+    void testEVT014_IntegrationPositive_SurvivorReceivesAnotherRobotsDeath() {
+        assertOnBothEngines(ROBOT, SOURCE, (outcome, engine) ->
+                assertTrue(outcome.anyConsoleContains(OTHER_DEATH),
+                        () -> "no survivor reported another robot's death on " + engine + " ("
+                                + outcome.summary() + ")"));
+    }
+}

conformance-test/src/test/java/dev/robocode/tankroyale/bridge/conformance/ConformanceHarness.java

@@ -35,4 +35,4 @@ The physics the events describe. That a `ScannedRobotEvent` arrives at the right
 
 `draft`. The redesign that routed events through the Bot API's own event queue is implemented and believed correct, but it was verified by running battles and reading scores. Every criterion here is unproven in the sense that matters: nothing would tell us if it broke again. `M-001` is the plan door.
 
-The conformance tier now reaches some of them. `EVT-004`, `EVT-011`, `EVT-012`, and `EVT-013` are active — the tests that already proved them were retagged after [`G-002`](../../goals/G-002-conformance-evidence-proves-the-criterion-it-names.md) found them mistagged, and `EVT-003` retired rather than be credited with evidence no available robot can produce ([`IDR-003`](../../decisions/IDR-003-evt-003-scoped-to-what-classic-actually-proves.md)). `EVT-004` is now proven with a locally built matched Tank Royale Bot API and runner pair under [`PDR-002`](../../decisions/PDR-002-locally-built-tank-royale-artifacts-for-conformance.md), which contains the server repair [`AN-009`](../../analysis/AN-009-the-server-never-sends-a-death-to-any-bot.md) identified. The capability still holds at `draft` because most criteria remain unproven, including `EVT-007`, which is blocked by the same original defect until the ported RobotDeathEvents evidence is wired.
+The conformance tier now reaches some of them. `EVT-004`, `EVT-011`, `EVT-012`, `EVT-013`, and `EVT-014` are active — the tests that already proved them were retagged after [`G-002`](../../goals/G-002-conformance-evidence-proves-the-criterion-it-names.md) found them mistagged, and `EVT-003`/`EVT-007` retired rather than be credited with evidence they cannot honestly claim ([`IDR-003`](../../decisions/IDR-003-evt-003-scoped-to-what-classic-actually-proves.md), [`IDR-004`](../../decisions/IDR-004-evt-007-scoped-to-observable-survivor-delivery.md)). `EVT-004` and `EVT-014` are proven with a locally built matched Tank Royale Bot API and runner pair under [`PDR-002`](../../decisions/PDR-002-locally-built-tank-royale-artifacts-for-conformance.md), which contains the server repair [`AN-009`](../../analysis/AN-009-the-server-never-sends-a-death-to-any-bot.md) identified. The capability still holds at `draft` because most criteria remain unproven.