acdream/tests/AcDream.App.Tests/Rendering/Walk/WalkOracleTraceTests.cs

namespace AcDream.App.Tests.Rendering.Walk;

/// <summary>
/// Integrity tests for the FW0 walk-oracle fixtures: every checked-in
/// trace parses, and the load-bearing shapes recorded in the fixture
/// README hold. FW1's conformance suite builds on these parsed frames;
/// if a fixture is edited or recaptured, these goldens catch drift.
/// </summary>
public sealed class WalkOracleTraceTests
{
    private const uint FarBuilding = 0xF518002Eu;

    public static readonly TheoryData<string> AllFixtures = new()
    {
        "terrace-center",
        "terrace-edge",
        "cathedral-arrival",
        "holtburg-doorway-still",
        "holtburg-walkout",
        "holtburg-street-porchcam",
        "holtburg-street-outdoor",
        "holtburg-walkabout",
        "foundry-entry",
        "foundry-deep",
    };

    [Theory]
    [MemberData(nameof(AllFixtures))]
    public void Fixture_parses_with_complete_frames(string name)
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load(name);

        Assert.NotEmpty(frames);
        // Frame numbers are contiguous from 1; the truncated final frame is dropped.
        Assert.Equal(1, frames[0].Number);
        Assert.Equal(frames.Count, frames[^1].Number);
        Assert.All(frames, f => Assert.NotEmpty(f.Events));
    }

    [Fact]
    public void Terrace_edge_draws_the_far_building_every_outdoor_frame()
    {
        // The #456 acceptance oracle: retail HIDES the vista by depth cover,
        // not by omission — 0xF518002E is submitted every single frame.
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("terrace-edge");

        Assert.All(frames, f =>
        {
            Assert.Null(f.InteriorRootCell);
            Assert.True(f.HasLandscape);
            Assert.Contains(FarBuilding, f.Buildings);
        });
    }

    [Fact]
    public void Cathedral_arrival_roots_interior_and_culls_the_far_building()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("cathedral-arrival");

        Assert.All(frames, f =>
        {
            Assert.Equal(0xF4180106u, f.InteriorRootCell);
            Assert.True(f.HasLandscape); // drawn THROUGH the exit view
            Assert.DoesNotContain(FarBuilding, f.Buildings);
        });
    }

    [Fact]
    public void Doorway_root_is_stable_across_every_frame()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("holtburg-doorway-still");

        Assert.All(frames, f => Assert.Equal(0xA9B4013Fu, f.InteriorRootCell));
    }

    [Fact]
    public void Walkout_hands_over_between_interior_cells_in_one_frame()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("holtburg-walkout");

        uint?[] roots = frames.Select(f => f.InteriorRootCell).Distinct().ToArray();
        Assert.Equal(new uint?[] { 0xA9B4013Fu, 0xA9B40150u }, roots);
        // Exactly one handover: the root sequence is two contiguous runs.
        int transitions = frames.Zip(frames.Skip(1))
            .Count(pair => pair.First.InteriorRootCell != pair.Second.InteriorRootCell);
        Assert.Equal(1, transitions);
    }

    [Fact]
    public void Street_porchcam_roots_at_the_camera_cell_not_the_player()
    {
        // The player stood in the street; the chase camera sat inside the
        // cottage porch — and retail rooted the frame at the CAMERA's cell.
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("holtburg-street-porchcam");

        Assert.All(frames, f => Assert.Equal(0xA9B40150u, f.InteriorRootCell));
    }

    [Fact]
    public void Street_outdoor_never_enters_an_interior_root()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("holtburg-street-outdoor");

        Assert.All(frames, f =>
        {
            Assert.Null(f.InteriorRootCell);
            Assert.True(f.HasLandscape);
        });
    }

    [Fact]
    public void Foundry_entry_flips_outdoor_to_interior_and_drops_the_landscape()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("foundry-entry");

        WalkOracleFrame flip = frames.First(f => f.InteriorRootCell is not null);
        Assert.Equal(0xA9B40178u, flip.InteriorRootCell);
        // The frame before the flip is fully outdoor; the flip frame itself
        // draws NO landscape and NO buildings — the pure-interior shape.
        WalkOracleFrame before = frames[flip.Number - 2];
        Assert.Null(before.InteriorRootCell);
        Assert.True(before.HasLandscape);
        Assert.False(flip.HasLandscape);
        Assert.Empty(flip.Buildings);
    }

    [Fact]
    public void Foundry_deep_draws_the_town_through_the_surviving_chain()
    {
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("foundry-deep");

        Assert.All(frames, f =>
        {
            Assert.Equal(0xA9B40176u, f.InteriorRootCell);
            Assert.True(f.HasLandscape);
            Assert.NotEmpty(f.Buildings);
        });
    }

    [Fact]
    public void Stationary_frames_repeat_their_event_sequence_exactly()
    {
        // README finding 6: while the camera is still, the whole-frame
        // sequence repeats bit-for-bit. Assert it on the terrace fixture.
        IReadOnlyList<WalkOracleFrame> frames = WalkOracleTrace.Load("terrace-center");

        WalkOracleFrame first = frames[0];
        Assert.All(frames.Skip(1), f =>
        {
            Assert.Equal(first.Events.Count, f.Events.Count);
            for (int i = 0; i < first.Events.Count; i++)
                Assert.Equal(first.Events[i], f.Events[i], WalkOracleEventComparer.Instance);
        });
    }

    private sealed class WalkOracleEventComparer : IEqualityComparer<WalkOracleEvent>
    {
        public static readonly WalkOracleEventComparer Instance = new();

        public bool Equals(WalkOracleEvent? x, WalkOracleEvent? y)
            => x is not null && y is not null
               && x.Kind == y.Kind
               && x.CellId == y.CellId
               && x.OutsideViewCount == y.OutsideViewCount
               && x.DeclaredCellCount == y.DeclaredCellCount
               && x.Cells.SequenceEqual(y.Cells);

        public int GetHashCode(WalkOracleEvent obj)
            => HashCode.Combine(obj.Kind, obj.CellId, obj.Cells.Count);
    }
}