Skip to content

A Civilization-style strategy game about governing Israel from 15 May 1948. Real ministers, real map, every fact sourced. Unity + deterministic C# sim.

27.1 KB
Raw Blame
using System;
using System.Collections.Generic;
using System.Linq;
using Statecraft.Sim;

/// <summary>Return to civilian life and reassignment (R-QUAL-001 to R-QUAL-007; #1511, owner ruling "Two-way, keep training"
/// and its three answers, 23 October 2026): instant and Money-free, qualified civilians are ordinary civilians for jobs, housing
/// and training, and a halutz's partial service is kept. The fixture's town_a has housing for 12, 8 jobs and 10 civilians, 6
/// in work; a halutz becomes a veteran after 4 turns of service.</summary>
public class QualificationTests
{
    static Content Town() => ContentLoader.Load(Fixture.Write(Fixture.Gdd()));

    /// <summary>town_a (1, 0) and town_b (2, 1), as DemobilizationTests lays them out.</summary>
    static Content TwoTowns() => ContentLoader.Load(Fixture.Write(Fixture.Gdd(new Dictionary<string, string>
    {
        ["map/settlement_hexes.yaml"] = "settlements:\n  - { id: town_a, q: 1, r: 0 }\n  - { id: town_b, q: 2, r: 1 }\n",
        ["map/settlements_1948.yaml"] = Fixture.Files["map/settlements_1948.yaml"]
            + "  - { id: town_b, name: Town B, lon: 34.42, lat: 33.28, type: town, founded: 1900, pre_modern: false }\n",
        ["map/locations_1948.yaml"] = Fixture.Files["map/locations_1948.yaml"]
            + "  - id: town_b\n    name: Town B\n    name_he: עיר ב\n    name_he_sources: [{ url: 'https://example.org/town-b-he', checked: 2026-10-18 }]\n    kind: city\n    lon: 34.42\n    lat: 33.28\n    q: 2\n    r: 1\n    priority: must_have\n    marker: true\n    managed_city: true\n    designated_site: false\n    settlement_control_target: false\n    sources: [{ url: 'https://example.org/town-b', checked: 2026-10-18 }]\n    status: draft\n",
        ["cities.yaml"] = "cities:\n" + Fixture.City("town_a", 40, 8, 10, 0) + Fixture.City("town_b", 40, 8, 10, 0),
    })));

    static StepResult Step(Content c, GameState s, params Command[] commands) => Simulation.Step(c, s, commands);

    static GameState WithCity(Content c, City city, params Unit[] units)
    {
        var s = Simulation.NewGame(c, 1, Mode.Historical);
        s.Cities[city.Id] = city;
        foreach (var u in units) { s.Units.Add(u.Id, u); s.NextId = Math.Max(s.NextId, u.Id + 1); }
        return s;
    }

    static int People(GameState s) => s.Cities.Values.Sum(x => x.Civilians + x.Craftsmen) + s.Units.Values.Count(u => Projects.IsPioneer(u.Type));

    // R-QUAL-002: instant, no Money; the craftsmen become qualified civilians, the jobs stay as they were.
    [Fact]
    public void CraftsmenReturnToCivilianLifeAndKeepTheirTraining()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 4, 0, craftsmen: 3, jobsDefault: false));
        var r = Step(c, s, new ReturnCraftsmen("town_a", 2));
        Assert.Empty(r.Rejected);
        var x = r.State.Cities["town_a"];
        Assert.Equal((6, 1, 2, 4), (x.Civilians, x.Craftsmen, x.Qualified.Craftsmen, x.Employed));
        Assert.Equal(People(s), People(r.State));
        // no Money is paid, and the 2 who returned earn the ordinary rate (R-QUAL-002): as the same city built by hand does
        var ordinary = WithCity(c, new City("town_a", 12, 8, 6, 4, 0, craftsmen: 1, jobsDefault: false));
        Assert.Equal(Step(c, ordinary).State.Treasury, r.State.Treasury, 9);
        Assert.Equal(Cities.Housed(s, s.Cities["town_a"]), Cities.Housed(r.State, x));
    }

    [Fact]
    public void ReturningCraftsmenIsRefusedForAnUnknownCityTooFewCraftsmenOrNoCount()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 0, 0, craftsmen: 1));
        foreach (var (cmd, why) in new (Command, string)[] {
            (new ReturnCraftsmen("nowhere", 1), "There is no such city"), (new ReturnCraftsmen("town_a", 0), "Return at least one group"),
            (new ReturnCraftsmen("town_a", 2), "Town A has 1 craftsmen") })
        {
            var r = Step(c, s, cmd);
            Assert.Equal(why, Assert.Single(r.Rejected).Reason);
            Assert.Equal(Step(c, s).State.Hash(), r.State.Hash());
        }
    }

    // R-QUAL-004: no training, no Money, no turns; the craftsmen are back at once.
    [Fact]
    public void QualifiedCraftsmenReturnWithoutTrainingOrMoney()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 6, 0, 0, jobsDefault: false, qualified: new Qualified(2, 0, new int[0])));
        var r = Step(c, s, new ReassignCraftsmen("town_a", 2));
        Assert.Empty(r.Rejected);
        Assert.Empty(r.State.Cohorts);
        var x = r.State.Cities["town_a"];
        Assert.Equal((4, 2, 0), (x.Civilians, x.Craftsmen, x.Qualified.Craftsmen));
        Assert.Equal(People(s), People(r.State));
        Assert.Equal(Step(c, s).State.Treasury, r.State.Treasury, 9);
    }

    // R-QUAL-004: a qualified civilian needs no job, nor does it take one that is taken.
    [Fact]
    public void ReassigningCraftsmenIsRefusedWithoutQualifiedOrIdleCivilians()
    {
        var c = Town();
        var q = new Qualified(2, 0, new int[0]);
        var busy = WithCity(c, new City("town_a", 12, 8, 4, 3, 0, jobsDefault: false, qualified: q));    // 3 of the 4 in work: 1 idle
        var r = Step(c, busy, new ReassignCraftsmen("town_a", 2));
        Assert.Equal("Town A has 1 civilians without work", Assert.Single(r.Rejected).Reason);
        Assert.Equal(Step(c, busy).State.Hash(), r.State.Hash());
        var none = WithCity(c, new City("town_a", 12, 8, 4, 0, 0, jobsDefault: false, qualified: q));
        foreach (var (cmd, why) in new (Command, string)[] {
            (new ReassignCraftsmen("town_a", 3), "Town A has 2 qualified craftsmen"), (new ReassignCraftsmen("town_a", 0), "Reassign at least one group"),
            (new ReassignCraftsmen("x", 1), "There is no such city") })
        {
            var refused = Step(c, none, cmd);
            Assert.Equal(why, Assert.Single(refused.Rejected).Reason);
            Assert.Equal(Step(c, none).State.Hash(), refused.State.Hash());   // R-QUAL-004: refused, state untouched
        }
    }

    // Owner ruling 2: a qualified civilian is an ordinary civilian for jobs, income and housing.
    [Fact]
    public void QualifiedCiviliansWorkHouseAndEarnAsOrdinaryOnes()
    {
        var c = Town();
        var plain = WithCity(c, new City("town_a", 12, 8, 5, 5, 0));
        var qualified = WithCity(c, new City("town_a", 12, 8, 5, 5, 0, jobsDefault: false, qualified: new Qualified(2, 1, new[] { 0, 3 })));
        Assert.Equal(Step(c, plain).State.Treasury, Step(c, qualified).State.Treasury, 9);          // ordinary rate, not the craftsman's
        Assert.Equal(Cities.Housed(plain, plain.Cities["town_a"]), Cities.Housed(qualified, qualified.Cities["town_a"]));
        Assert.Equal(Cities.MaxWorkers(plain.Cities["town_a"]), Cities.MaxWorkers(qualified.Cities["town_a"]));
        Assert.Equal(Training.Idle(plain.Cities["town_a"]), Training.Idle(qualified.Cities["town_a"]));
    }

    // R-QUAL-006: training takes the unqualified first; a qualified civilian taken loses its qualification.
    [Fact]
    public void TrainingTakesUnqualifiedCiviliansFirstAndThenQualifiedOnes()
    {
        var c = Town();
        var q = new Qualified(2, 1, new[] { 2, 3 });
        var s = WithCity(c, new City("town_a", 12, 8, 6, 0, 0, jobsDefault: false, qualified: q));   // 5 qualified of 6 civilians
        var one = Step(c, s, new Train("town_a", "halutz", 1));
        Assert.Empty(one.Rejected);
        Assert.Equal(5, one.State.Cities["town_a"].Qualified.Total);             // the unqualified one went
        var three = Step(c, s, new Train("town_a", "halutz", 3));
        Assert.Empty(three.Rejected);
        var left = three.State.Cities["town_a"];
        Assert.Equal(3, left.Civilians);
        Assert.Equal((0, 2, 1), (left.Qualified.Craftsmen, left.Qualified.Halutzim.Count, left.Qualified.Veterans));   // the craftsmen went first
        var four = Step(c, s, new Train("town_a", "halutz", 5)).State.Cities["town_a"];
        Assert.Equal((1, 0, 0, 1), (four.Civilians, four.Qualified.Craftsmen, four.Qualified.Halutzim.Count, four.Qualified.Veterans));   // then the halutzim, the veterans last
        Assert.All(new[] { left, four }, x => Assert.True(x.Qualified.Total <= x.Civilians));
    }

    // R-QUAL-003 and owner ruling 3: a halutz keeps the service it had.
    [Fact]
    public void AnIdleHalutzReturnsToTheNearestCityKeepingItsService()
    {
        var c = TwoTowns();
        var s = WithCity(c, new City("town_a", 40, 8, 1, 0, 0), new Unit(7, "halutz", 2, 1, 3));   // on town_b's hex
        s.Cities["town_b"] = new City("town_b", 40, 8, 1, 0, 0);
        var r = Step(c, s, new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Empty(r.Rejected);
        Assert.DoesNotContain(7, r.State.Units.Keys);
        var b = r.State.Cities["town_b"];
        Assert.Equal(2, b.Civilians);
        Assert.Equal(new[] { 3 }, b.Qualified.Halutzim);
        Assert.Equal(1, r.State.Cities["town_a"].Civilians);
        Assert.Equal(People(s), People(r.State));
    }

    // R-QUAL-003: the nearest city, ties by city id (R-UNIT-005's rule).
    [Fact]
    public void TheReturningUnitTiesGoToTheLowestCityId()
    {
        var c = TwoTowns();
        var s = WithCity(c, new City("town_a", 40, 8, 1, 0, 0), new Unit(7, "veteran_halutz", 2, 0, 4));   // 1 from town_a (1,0) and 1 from town_b (2,1)
        s.Cities["town_b"] = new City("town_b", 40, 8, 1, 0, 0);
        var r = Step(c, s, new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Empty(r.Rejected);
        Assert.Equal((2, 1), (r.State.Cities["town_a"].Civilians, r.State.Cities["town_a"].Qualified.Veterans));
        Assert.Equal(0, r.State.Cities["town_b"].Qualified.Total);
    }

    [Fact]
    public void AUnitAtWorkAndAUnitThatIsNotAPioneerAreRefused()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 0, 0), new Unit(7, "halutz", 1, 0), new Unit(8, "recruit", 1, 0, side: "israel", strength: 2));
        var working = Step(c, s, new PioneerWork(7, Projects.BuildYishuv, "site_a")).State;
        Assert.True(Projects.IsBusy(working, 7));
        var busy = Step(c, working, new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Equal("That unit is at work; stop the work first", Assert.Single(busy.Rejected).Reason);
        Assert.Contains(7, busy.State.Units.Keys);
        Assert.Equal(Step(c, working).State.Hash(), busy.State.Hash());   // R-QUAL-003: refused, state unchanged
        var notPioneer = Step(c, s, new UnitOrder(8, Qualification.ReturnOrder));
        Assert.Equal("Only a pioneer unit takes that order", Assert.Single(notPioneer.Rejected).Reason);
        Assert.Equal(Step(c, s).State.Hash(), notPioneer.State.Hash());
        var unknown = Step(c, s, new UnitOrder(99, Qualification.ReturnOrder));
        Assert.Equal("There is no such unit", Assert.Single(unknown.Rejected).Reason);
        Assert.Equal(Step(c, s).State.Hash(), unknown.State.Hash());
        // Projects.IsBusy counts a corridor segment as work too (#2806 item 1)
        var road = Step(c, s, new PioneerWork(7, Corridors.BuildRoad, "road_a:1")).State;
        Assert.True(Projects.IsBusy(road, 7));
        var onRoad = Step(c, road, new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Equal("That unit is at work; stop the work first", Assert.Single(onRoad.Rejected).Reason);
        Assert.Equal(Step(c, road).State.Hash(), onRoad.State.Hash());
        Assert.Equal("That order names no hex", Assert.Single(Step(c, s, new UnitOrder(7, Qualification.ReturnOrder, 1, 0)).Rejected).Reason);
        // stopped, it goes at once
        var stopped = Step(c, working, new StopWork(7), new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Empty(stopped.Rejected);
        Assert.DoesNotContain(7, stopped.State.Units.Keys);
    }

    // R-QUAL-005: units appear at the settlement hex, the halutz with the most service first, a veteran as a veteran.
    [Fact]
    public void QualifiedPioneersReappearAsUnitsAtTheSettlementHex()
    {
        var c = Town();
        var q = new Qualified(0, 2, new[] { 0, 2, 3 });
        var s = WithCity(c, new City("town_a", 12, 8, 6, 0, 0, jobsDefault: false, qualified: q));
        var halutz = Step(c, s, new ReassignPioneers("town_a", "halutz", 2));
        Assert.Empty(halutz.Rejected);
        var units = halutz.State.Units.Values.OrderBy(u => u.Id).ToList();
        Assert.Equal(new[] { 3, 2 }, units.Select(u => u.Service));
        Assert.All(units, u => Assert.Equal(("halutz", 1, 0, ""), (u.Type, u.Q, u.R, u.Side)));
        Assert.Equal(new[] { 0 }, halutz.State.Cities["town_a"].Qualified.Halutzim);
        Assert.Equal(4, halutz.State.Cities["town_a"].Civilians);
        Assert.Equal(People(s), People(halutz.State));
        Assert.Equal(Step(c, s).State.Treasury, halutz.State.Treasury, 9);

        var vet = Step(c, s, new ReassignPioneers("town_a", "veteran_halutz", 1));
        Assert.Empty(vet.Rejected);
        var u1 = Assert.Single(vet.State.Units.Values);
        Assert.Equal(("veteran_halutz", 4, 1, 0), (u1.Type, u1.Service, u1.Q, u1.R));
        Assert.Equal(1, vet.State.Cities["town_a"].Qualified.Veterans);
        Assert.Equal(3, vet.State.Cities["town_a"].Qualified.Halutzim.Count);   // the halutzim are untouched
    }

    [Fact]
    public void ReassigningPioneersIsRefusedAsStated()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 3, 2, 0, jobsDefault: false, qualified: new Qualified(0, 1, new[] { 1, 1 })));   // 1 idle
        foreach (var (cmd, why) in new (Command, string)[] {
            (new ReassignPioneers("nowhere", "halutz", 1), "There is no such city"),
            (new ReassignPioneers("town_a", "soldier", 1), "There is no such qualification"),
            (new ReassignPioneers("town_a", "halutz", 0), "Reassign at least one group"),
            (new ReassignPioneers("town_a", "veteran_halutz", 2), "Town A has 1 qualified veteran pioneers"),
            (new ReassignPioneers("town_a", "halutz", 3), "Town A has 2 qualified halutzim"),
            (new ReassignPioneers("town_a", "halutz", 2), "Town A has 1 civilians without work") })
        {
            var r = Step(c, s, cmd);
            Assert.Equal(why, Assert.Single(r.Rejected).Reason);
            Assert.Equal(Step(c, s).State.Hash(), r.State.Hash());
        }
    }

    // Done-when: nobody is duplicated or lost over a full round trip, a veteran stays one, service is kept.
    [Fact]
    public void ARoundTripKeepsEveryPersonAndTheirStatus()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 0, 0, craftsmen: 1, jobsDefault: false), new Unit(5, "halutz", 1, 0, 2), new Unit(6, "veteran_halutz", 1, 0, 4));
        var before = People(s);
        s = Step(c, s, new UnitOrder(5, Qualification.ReturnOrder), new UnitOrder(6, Qualification.ReturnOrder), new ReturnCraftsmen("town_a", 1)).State;
        Assert.Equal(before, People(s));
        Assert.Empty(s.Units);
        Assert.Equal((7, 0, 3), (s.Cities["town_a"].Civilians, s.Cities["town_a"].Craftsmen, s.Cities["town_a"].Qualified.Total));
        s = Step(c, s, new ReassignPioneers("town_a", "halutz", 1), new ReassignPioneers("town_a", "veteran_halutz", 1), new ReassignCraftsmen("town_a", 1)).State;
        Assert.Equal(before, People(s));
        var x = s.Cities["town_a"];
        Assert.Equal((4, 1, 0), (x.Civilians, x.Craftsmen, x.Qualified.Total));
        Assert.Equal(new[] { ("halutz", 2), ("veteran_halutz", 4) }, s.Units.Values.OrderBy(u => u.Id).Select(u => (u.Type, u.Service)));
    }

    // R-QUAL-007: nothing is written for a city without qualified civilians; the order they returned in does not matter.
    [Fact]
    public void QualifiedCiviliansReachTheHashOnlyWhenThereAreSomeInASortedOrder()
    {
        string H(City x) { var g = new GameState(); g.Cities[x.Id] = x; return g.Hash(); }
        var none = new City("a", 1, 1, 3, 1, 0);
        Assert.Equal(H(none), H(new City("a", 1, 1, 3, 1, 0, qualified: Qualified.None)));
        Assert.Equal("a=1,1,3,1,0", none.Canonical());
        var hashes = new[] { new Qualified(1, 0, new int[0]), new Qualified(0, 1, new int[0]), new Qualified(0, 0, new[] { 2 }), new Qualified(0, 0, new[] { 2, 3 }),
            }.Select(q => H(new City("a", 1, 1, 3, 1, 0, qualified: q))).Append(H(none)).ToList();
        Assert.Equal(hashes.Count, new HashSet<string>(hashes).Count);
        Assert.Equal(new Qualified(0, 0, new int[0]).AddHalutz(3).AddHalutz(2).Canonical(), new Qualified(0, 0, new int[0]).AddHalutz(2).AddHalutz(3).Canonical());
        Assert.Equal(",qcraftsmen=1,qhalutz=2:3,qveterans=2", new Qualified(1, 2, new[] { 2, 3 }).Canonical());
    }

    // R-SAVE: the new orders are saved and replayed to the same state, in a scenario and as a unit order.
    [Fact]
    public void TheNewOrdersSaveReplayAndRunInAScenario()
    {
        var c = Town();
        var g = GameSession.New(c, 1, Mode.Historical);
        g.State.Cities["town_a"] = new City("town_a", 12, 8, 4, 0, 0, craftsmen: 1);
        g.State.Units.Add(g.State.NextId, new Unit(g.State.NextId, "halutz", 1, 0, 2));
        var unit = g.State.NextId++;
        g.Step(new Command[] { new ReturnCraftsmen("town_a", 1), new UnitOrder(unit, Qualification.ReturnOrder) });
        var text = g.Save.Write();
        Assert.Contains("retcraft town_a 1", text);
        Assert.Contains("order " + unit + " return_civilian", text);
        // R-QUAL-007 (#2806 item 3): the two reassignment tokens are pinned too, and parse back to the same city, track and count.
        foreach (var (cmd, token) in new (Command, string)[] { (new ReassignCraftsmen("town_a", 2), "regcraft town_a 2"),
                     (new ReassignPioneers("town_a", "veteran_halutz", 1), "regpioneer town_a veteran_halutz 1") })
        {
            var other = GameSession.New(c, 1, Mode.Historical);
            other.Step(new[] { cmd });   // refused here, but written and parsed back as the same order
            var saved = other.Save.Write();
            Assert.Contains(token, saved);
            var back = SaveGame.Parse(saved).Turns.Single().Single();
            Assert.Equal(cmd.GetType(), back.GetType());
            if (cmd is ReassignCraftsmen rc)
                Assert.Equal((rc.City, rc.Count), (((ReassignCraftsmen)back).City, ((ReassignCraftsmen)back).Count));
            else
            {
                var rp = (ReassignPioneers)cmd;
                var bp = (ReassignPioneers)back;
                Assert.Equal((rp.City, rp.Track, rp.Count), (bp.City, bp.Track, bp.Count));
            }
        }
        var yaml = "name: q\nuntil: 1948-06-01\nsteps:\n  - on: 1948-05-15\n    commands:\n      - { kind: reassign_pioneers, city: town_a, track: halutz, count: 1 }\n";
        var built = Scenario.Parse(yaml).Steps.Single().Built.Single();
        Assert.Equal(("town_a", "halutz", 1), (((ReassignPioneers)built).City, ((ReassignPioneers)built).Track, ((ReassignPioneers)built).Count));
    }

    // R-QUAL-002 and R-QUAL-004: Employed is untouched by a return and by a reassignment, and Idle stays as it was.
    [Fact]
    public void EmployedAndIdleAreUnchangedByReturnAndReassignment()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 5, 0, craftsmen: 3, jobsDefault: false));   // 5 in work: 3 craftsmen and 2 civilians
        var idle = Training.Idle(s.Cities["town_a"]);
        var back = Step(c, s, new ReturnCraftsmen("town_a", 2)).State.Cities["town_a"];
        Assert.Equal((5, idle), (back.Employed, Training.Idle(back)));
        var again = Step(c, WithCity(c, back), new ReassignCraftsmen("town_a", 2));
        Assert.Empty(again.Rejected);
        var x = again.State.Cities["town_a"];
        Assert.Equal((5, idle, 3, 0), (x.Employed, Training.Idle(x), x.Craftsmen, x.Qualified.Total));
    }

    // R-SAVE: a played session of the new orders replays to the live state, and the other scenario kinds build.
    [Fact]
    public void ASessionOfTheNewOrdersReplaysToTheSameHash()
    {
        var c = Town();
        var g = GameSession.New(c, 1, Mode.Historical);
        g.Step(new Command[] { new Train("town_a", "halutz", 1) });
        var loaded = GameSession.Load(c, g.Save.Write(), out var warnings);
        Assert.Empty(warnings);
        Assert.Equal(g.State.Hash(), loaded.State.Hash());
        var yaml = "name: q\nuntil: 1948-06-01\nsteps:\n  - on: 1948-05-15\n    commands:\n      - { kind: return_craftsmen, city: town_a, count: 1 }\n      - { kind: reassign_craftsmen, city: town_a, count: 2 }\n      - { kind: unit_order, unit: 3, order: return_civilian }\n";
        var built = Scenario.Parse(yaml).Steps.Single().Built;
        Assert.Equal(new[] { typeof(ReturnCraftsmen), typeof(ReassignCraftsmen), typeof(UnitOrder) }, built.Select(x => x.GetType()));
        Assert.Equal(Qualification.ReturnOrder, ((UnitOrder)built[2]).Order);
    }

    // Owner ruling 1: "the normal Attention of an order": a craftsman's is assign_workers' 0.5, a pioneer unit's is free.
    [Fact]
    public void TheOrdersCostTheNormalAttentionOfAnOrder()
    {
        var c = ContentLoader.Load(RealContentTests.ContentRoot());
        var s = Simulation.NewGame(c, 1, Mode.Historical);
        Assert.Equal(AttentionSystem.Cost(c, s, "assign_workers"), AttentionSystem.Cost(c, s, Qualification.ReturnCraftsmenKind));
        Assert.Equal(AttentionSystem.Cost(c, s, "assign_workers"), AttentionSystem.Cost(c, s, Qualification.ReassignCraftsmenKind));
        Assert.Equal(AttentionSystem.Cost(c, s, "unit_order"), AttentionSystem.Cost(c, s, Qualification.ReassignPioneersKind));
        Assert.Equal(0, AttentionSystem.Cost(c, s, "unit_order"));
    }

    // R-TRAIN-001 with R-QUAL-004, R-QUAL-005 (#1548; owner, 24 October 2026: "Yes, count them",
    // https://github.com/eyalgolan/statecraft-israel/issues/1511#issuecomment-6378360813): a queued reassignment takes its
    // city's idle civilians as a queued Train does, for its own city only.
    [Fact]
    public void AQueuedReassignCountsAgainstTheCitysFreeCivilians()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 10, 0, 0, craftsmen: 0, qualified: new Qualified(3, 1, new[] { 1, 2 })));
        var queue = new Command[] { new Train("town_a", "recruit", 1), new ReassignCraftsmen("town_a", 2), new ReassignPioneers("town_a", "halutz", 1),
            new ReassignPioneers("town_a", "veteran_halutz", 1), new ReassignCraftsmen("elsewhere", 5) };
        Assert.Equal(5, Training.Ordered("town_a", queue));
        Assert.Equal(5, Training.Available(s, "town_a", queue));   // 10 idle civilians less those 5
        Assert.Equal(10, Training.Available(s, "town_a", new Command[] { new ReassignCraftsmen("elsewhere", 5), new ReassignPioneers("elsewhere", "halutz", 2) }));
    }

    // The count is the one the sim accepts: the orders up to Available all run, in either order, and one group more is refused.
    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public void AvailableAfterQueuedReassignsKeepsEveryOrderAccepted(bool trainFirst)
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 0, 0, craftsmen: 0, qualified: new Qualified(2, 0, new[] { 1 })));
        s.Attention = 100;
        var reassigns = new Command[] { new ReassignCraftsmen("town_a", 1), new ReassignPioneers("town_a", "halutz", 1) };
        Assert.Equal(2, Training.Available(s, "town_a", reassigns));
        Command[] Orders(int recruits) => trainFirst
            ? new Command[] { new Train("town_a", "recruit", recruits), reassigns[0], reassigns[1] }
            : new Command[] { reassigns[0], reassigns[1], new Train("town_a", "recruit", recruits) };
        Assert.Empty(Step(c, s, Orders(2)).Rejected);
        Assert.Single(Step(c, s, Orders(3)).Rejected);
    }

    // R-CITY-001 with R-QUAL-004, R-QUAL-005 (#1548): every queued reassignment counts against MaxWorkers in full, so the job
    // order up to it is accepted with the reassignments whether it runs first or last (the bound is safe, not tight).
    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public void MaxWorkersCountsEveryQueuedReassignInAnyOrder(bool jobsFirst)
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 6, 0, 0, craftsmen: 0, jobsDefault: false, qualified: new Qualified(2, 0, new[] { 1 })));
        Assert.Equal(6, Cities.MaxWorkers(s, "town_a", new Command[0]));
        Assert.Equal(4, Cities.MaxWorkers(s, "town_a", new Command[] { new ReassignCraftsmen("town_a", 2) }));
        Assert.Equal(5, Cities.MaxWorkers(s, "town_a", new Command[] { new ReassignPioneers("town_a", "halutz", 1) }));
        var queue = new Command[] { new ReassignCraftsmen("town_a", 2), new ReassignPioneers("town_a", "halutz", 1) };
        var max = Cities.MaxWorkers(s, "town_a", queue);
        Assert.Equal(3, max);
        s.Attention = 100;
        Command[] Orders(int jobs) => jobsFirst
            ? new Command[] { new AssignWorkers("town_a", "job", jobs) }.Concat(queue).ToArray()
            : queue.Append(new AssignWorkers("town_a", "job", jobs)).ToArray();
        Assert.Empty(Step(c, s, Orders(max)).Rejected);
    }

    // Production rows must carry the literal localization contract, not only an English fallback message.
    [Fact]
    public void QualificationOrdersEmitTheirLocalizationKeysAndArguments()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 6, 0, 0, craftsmen: 3, jobsDefault: false,
            qualified: new Qualified(3, 2, new[] { 1 })), new Unit(7, "halutz", 1, 0, 2));
        s.Attention = 100;
        var returned = Step(c, s, new ReturnCraftsmen("town_a", 2), new UnitOrder(7, Qualification.ReturnOrder));
        Assert.Empty(returned.Rejected);
        Assert.Equal(new[] { "2" }, Assert.Single(returned.Why, x => x.Key == "craftsmen_returned").Args);
        Assert.Equal(new[] { "town_a" }, Assert.Single(returned.Why, x => x.Key == "pioneer_returned").Args);
        var reassigned = Step(c, s, new ReassignCraftsmen("town_a", 1), new ReassignPioneers("town_a", "veteran_halutz", 1));
        Assert.Empty(reassigned.Rejected);
        Assert.Equal(new[] { "1" }, Assert.Single(reassigned.Why, x => x.Key == "craftsmen_reassigned").Args);
        Assert.Equal(new[] { "1", "veteran" }, Assert.Single(reassigned.Why, x => x.Key == "pioneers_reassigned").Args);
        var halutz = Step(c, s, new ReassignPioneers("town_a", "halutz", 1));
        Assert.Empty(halutz.Rejected);
        Assert.Equal(new[] { "1", "halutz" }, Assert.Single(halutz.Why, x => x.Key == "pioneers_reassigned").Args);
    }

    // #2513: a clone shares its records, so a record's lists must not be arrays a cast could write through. Writing through
    // whatever the list is backed by, on the clone, leaves the original's hash alone.
    [Fact]
    public void ACloneCannotWriteThroughTheListsItSharesWithTheOriginal()
    {
        var c = Town();
        var s = WithCity(c, new City("town_a", 12, 8, 4, 0, 0, qualified: new Qualified(0, 0, new[] { 1, 2 })));
        s.Corridors["road_a"] = new CorridorWork("road_a", new SegmentWork?[] { new SegmentWork(null, 6, new DateTime(1948, 5, 15)), null });
        var before = s.Hash();
        var clone = s.Clone();
        Assert.Throws<NotSupportedException>(() => ((IList<int>)clone.Cities["town_a"].Qualified.Halutzim)[0] = 9);
        Assert.Throws<NotSupportedException>(() => ((IList<SegmentWork?>)clone.Corridors["road_a"].Segments)[0] = null);
        Assert.Equal(before, s.Hash());
        Assert.Equal(before, clone.Hash());
    }
}