go-test-hang-tickdt-zero-frozen-simtime

Answer

Root cause (KB-GAP-026): pkg/debug's test built a bare benchmark.Config struct literal, so TickDT defaulted to 0. The engine advances SimTime by TickDT per tick, so SimTime never moved; RunToDecisionPoint loops until SimTime >= next, and ctx was only consulted between turns — cancellation could never break the spin. The runner therefore never completed an episode and the non-short suite burned the full 180s -timeout.

Fix 1 — base test config on DefaultConfig(), pin MaxTurns (pkg/debug/debug_test.go):

func testConfig() benchmark.Config {
    cfg := benchmark.DefaultConfig() // TickDT = 0.02 -> SimTime advances
    cfg.MapSize = 32
    cfg.Robots = 4
    cfg.MaxTurns = 100 // explicit cap: episode always terminates
    return cfg
}

func TestEpisodeCompletes(t *testing.T) {
    cfg := testConfig()
    if cfg.TickDT <= 0 {
        t.Fatalf("test config must have TickDT > 0 (got %v): SimTime would be frozen", cfg.TickDT)
    }
    if cfg.MaxTurns == 0 {
        t.Fatal("test config must set MaxTurns: unlimited turns can hang the suite")
    }
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    r := benchmark.NewRunner(cfg)
    if err := r.Episode(ctx); err != nil {
        t.Fatalf("episode failed: %v", err)
    }
    if r.Turns() != cfg.MaxTurns {
        t.Fatalf("episode stopped after %d turns, want %d", r.Turns(), cfg.MaxTurns)
    }
}

Fix 2 — gate the 10-minute stability test behind -long:

var longStability = flag.Bool("long", false, "run the 10-minute stability suite")

func TestTenMinuteStability(t *testing.T) {
    if !*longStability {
        t.Skip("skipping 10-minute stability suite; pass -long to enable")
    }
    // full soak: context.WithTimeout(..., 10*time.Minute) driving Episode(...)
}

Fix 3 — guard the 0/0 ValidActionRate division (pkg/debug/stats.go):

// ValidActionRate returns valid/total in [0,1]. total == 0 -> 0, never NaN,
// so downstream formatting and threshold checks behave.
func ValidActionRate(valid, total int) float64 {
    if total == 0 {
        return 0
    }
    return float64(valid) / float64(total)
}

Fix 4 (hardening) — check ctx on every tick, not just between turns (pkg/benchmark/runner.go), so even a zero/stuck TickDT can no longer wedge the suite:

func (r *Runner) RunToDecisionPoint(ctx context.Context) error {
    next := r.cfg.TurnInterval
    for {
        select {
        case <-ctx.Done():
            return ctx.Err() // per-tick check: cancellation always wins
        default:
        }
        r.engine.Step()
        r.engine.SimTime += r.cfg.TickDT
        if r.engine.SimTime >= next {
            r.turns++
            next += r.cfg.TurnInterval
            return nil
        }
    }
}