acdream/tests/AcDream.App.Tests/Rendering/RetailPViewPassExecutorTests.cs

using System.Reflection;
using AcDream.App.Composition;
using AcDream.App.Rendering;
using AcDream.App.Tests.Architecture;

namespace AcDream.App.Tests.Rendering;

public sealed class RetailPViewPassExecutorTests
{
    [Fact]
    public void Extracted_contracts_retain_no_window_callbacks_or_visibility_owner()
    {
        Assert.DoesNotContain(
            typeof(RetailPViewFrameInput).GetProperties(),
            property => typeof(Delegate).IsAssignableFrom(property.PropertyType));

        FieldInfo[] fields = typeof(RetailPViewPassExecutor).GetFields(
            BindingFlags.Instance | BindingFlags.NonPublic);
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(GameWindow));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(CellVisibility));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(RetailPViewFrameInput));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(RetailPViewFrameResult));
        Assert.DoesNotContain(fields, field => field.FieldType == typeof(ClipFrameAssembly));
        Assert.DoesNotContain(
            fields,
            field => typeof(Delegate).IsAssignableFrom(field.FieldType));
    }

    [Fact]
    public void Concrete_executor_brackets_terrain_diagnostics()
    {
        MethodInfo landscape = typeof(RetailPViewPassExecutor).GetMethod(
            "DrawWalkLandCellBatch",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> landscapeCalls = CompiledCallGraph.Read(landscape);
        int diagnosticsBegin = RequiredCallIndex(
            landscapeCalls,
            typeof(TerrainDrawDiagnosticsController),
            nameof(TerrainDrawDiagnosticsController.Begin));
        int terrainDraw = RequiredCallIndex(
            landscapeCalls,
            typeof(TerrainModernRenderer),
            nameof(TerrainModernRenderer.DrawLandCellRuns));
        int diagnosticsComplete = RequiredCallIndex(
            landscapeCalls,
            typeof(TerrainDrawDiagnosticsController),
            nameof(TerrainDrawDiagnosticsController.Complete));

        Assert.True(diagnosticsBegin < terrainDraw);
        Assert.True(terrainDraw < diagnosticsComplete);
    }

    [Fact]
    public void Frame_composition_constructs_one_walk_executor()
    {
        MethodInfo compose = typeof(FrameRootCompositionPhase).GetMethod(
            "ComposeCore",
            BindingFlags.Instance | BindingFlags.NonPublic)!;
        IReadOnlyList<CompiledCall> calls = CompiledCallGraph.Read(compose);

        int executor = RequiredCallIndex(
            calls,
            typeof(RetailPViewPassExecutor),
            ".ctor");
        int renderer = RequiredCallIndex(
            calls,
            typeof(WorldScenePViewRenderer),
            ".ctor");

        Assert.True(executor < renderer);
        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(RetailPViewPassExecutor)
                && call.Target.Name == ".ctor");
        Assert.Single(
            calls,
            call => call.Target.DeclaringType == typeof(WorldScenePViewRenderer)
                && call.Target.Name == ".ctor");
    }

    private static int RequiredCallIndex(
        IReadOnlyList<CompiledCall> calls,
        Type declaringType,
        string methodName)
    {
        int index = CompiledCallGraph.IndexOf(calls, declaringType, methodName);
        Assert.True(
            index >= 0,
            $"Expected call to {declaringType.Name}.{methodName}.");
        return index;
    }
}