Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

11.8 KB
Raw Blame
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Core.Topology;
using Aetheris.Kernel.Firmament.Assembly;

namespace Aetheris.Kernel.Firmament.Tests.Assembly;

public sealed class IncrementalCompilationTests
{
    private const string Recipe = """
        Template<H: Length> Struct Pad {
          Rect2 Outline { Center: [0mm,0mm]; Size: [10mm,10mm] }
          Profile P { Loop Outer { Outline |> TraceLoop } }
          Extrude Body { Profile: P From: 0mm To: H }
        }
        """;
    private static string Source(string height = "2mm", string position = "20mm") => Recipe + $$"""

        Assembly Test {
          <Assembly Test>
            <Part A = Pad<H:{{height}}>> Placement { From: Origin; To: World; } </Part>
            <Part B = Pad<H:{{height}}>> Placement { From: Origin; To: World; TranslateLocal: [{{position}},0mm,0mm]; } </Part>
          </Assembly>
          Anchor: Test;
        }
        """;

    private static AssemblyM1CompilationResult Good(AssemblyM1CompilationResult result)
    {
        Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics.Select(d => d.Message)));
        return result;
    }

    [Fact]
    public void RepeatedBuildReusesOneDefinitionAndMatchesUncachedExactOutput()
    {
        using var session = new FirmamentCompilationSession();
        var first = Good(session.Compile(Source()));
        var second = Good(session.Compile(Source()));
        var baseline = Good(new AssemblyM1Pipeline().Compile(Source()));
        Assert.Equal(1, first.Reuse!.RebuiltDefinitions);
        Assert.Equal(1, second.Reuse!.ReusedDefinitions);
        Assert.Equal(0, second.Reuse.RebuiltDefinitions);
        Assert.Equal(baseline.Geometry!.Artifact.DeterministicSha256, second.Geometry!.Artifact.DeterministicSha256);
        Assert.Equal(AssemblyIrAp242Exporter.Export(baseline).Value, AssemblyIrAp242Exporter.Export(second).Value);
        Assert.NotSame(first.Geometry!.DefinitionBodies.Values.Single(), second.Geometry.DefinitionBodies.Values.Single());
    }

    [Fact]
    public void SessionDisplayMeshOfReusedDefinitionMatchesAFreshExport()
    {
        using var session = new FirmamentCompilationSession();
        var first = Good(session.Compile(Source()));
        var firstMesh = AssemblyDisplayMeshExporter.Serialize(session.ExportDisplayMesh(first));
        var second = Good(session.Compile(Source()));
        Assert.Equal(1, second.Reuse!.ReusedDefinitions);
        var baseline = Good(new AssemblyM1Pipeline().Compile(Source()));
        var expected = AssemblyDisplayMeshExporter.Serialize(AssemblyDisplayMeshExporter.Export(baseline));
        Assert.Equal(expected, firstMesh);
        Assert.Equal(expected, AssemblyDisplayMeshExporter.Serialize(session.ExportDisplayMesh(second)));
    }

    [Fact]
    public void SourceOnlyEditRebuildsTheDefinitionButReusesItsUnchangedDisplayMesh()
    {
        // BUILD-PERF-M2: derived values are keyed by definition content (identity, canonical STEP,
        // retained CIR), not by source text, so a comment in the declarations re-materializes the
        // definition but keeps the prepared mesh object (the web runtime retains it by reference).
        using var session = new FirmamentCompilationSession();
        var first = Good(session.Compile(Source()));
        var firstMesh = session.ExportDisplayMesh(first);
        var commented = Source().Replace("Struct Pad {", "Struct Pad {\n  // declarations comment", StringComparison.Ordinal);
        var second = Good(session.Compile(commented));
        Assert.Equal(1, second.Reuse!.RebuiltDefinitions);
        var secondMesh = session.ExportDisplayMesh(second);
        Assert.Same(firstMesh.Definitions.Single(), secondMesh.Definitions.Single());
        var baseline = Good(new AssemblyM1Pipeline().Compile(commented));
        Assert.Equal(AssemblyDisplayMeshExporter.Serialize(AssemblyDisplayMeshExporter.Export(baseline)), AssemblyDisplayMeshExporter.Serialize(secondMesh));
        var taller = Good(session.Compile(Source(height: "3mm")));
        Assert.NotSame(firstMesh.Definitions.Single(), session.ExportDisplayMesh(taller).Definitions.Single());
    }

    [Fact]
    public void SceneRebuildReusesItsDisplayDefinitions()
    {
        var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/Scene/WarmModernHouse/house.firmament");
        using var session = new Aetheris.Kernel.Firmament.Scene.FirmamentSceneSession();
        var first = session.CompileFile(path);
        Assert.True(first.IsSuccess, string.Join("\n", first.Diagnostics.Select(d => d.Message)));
        var second = session.CompileFile(path);
        Assert.True(second.IsSuccess);
        var fresh = new Aetheris.Kernel.Firmament.Scene.FirmamentSceneSession().CompileFile(path);
        Assert.Equal(first.Scene!.Display.Definitions.Count, second.Scene!.Display.Definitions.Count);
        Assert.All(first.Scene.Display.Definitions.Zip(second.Scene.Display.Definitions), pair => Assert.Same(pair.First, pair.Second));
        Assert.All(DisplayProjection.Project(first.Scene).Definitions.Zip(DisplayProjection.Project(second.Scene).Definitions), pair => Assert.Same(pair.First, pair.Second));
        Assert.Equal(AssemblyDisplayMeshExporter.Serialize(DisplayProjection.Project(fresh.Scene!)), AssemblyDisplayMeshExporter.Serialize(DisplayProjection.Project(second.Scene)));
    }

    [Fact]
    public void MutatingAReusedBodyCannotLeakIntoTheNextBuild()
    {
        using var session = new FirmamentCompilationSession();
        Good(session.Compile(Source()));
        var reused = Good(session.Compile(Source()));
        var body = reused.Geometry!.DefinitionBodies.Values.Single();
        body.Topology.AddVertex(new Vertex(new VertexId(1_000_000)));
        var next = Good(session.Compile(Source()));
        var baseline = Good(new AssemblyM1Pipeline().Compile(Source()));
        Assert.Equal(1, next.Reuse!.ReusedDefinitions);
        Assert.Equal(AssemblyIrAp242Exporter.Export(baseline).Value, AssemblyIrAp242Exporter.Export(next).Value);
        Assert.Equal(baseline.Geometry!.DefinitionBodies.Values.Single().Topology.Vertices.Count(),
            next.Geometry!.DefinitionBodies.Values.Single().Topology.Vertices.Count());
    }

    [Fact]
    public void PlacementEditReusesGeometryButRevalidatesInterference()
    {
        using var session = new FirmamentCompilationSession();
        Good(session.Compile(Source()));
        var moved = Good(session.Compile(Source(position: "30mm")));
        Assert.Equal(1, moved.Reuse!.ReusedDefinitions);
        var overlapping = session.Compile(Source(position: "00mm"));
        Assert.False(overlapping.IsSuccess);
        Assert.Equal(1, overlapping.Reuse!.ReusedDefinitions);
        Assert.Contains(overlapping.Diagnostics, d => d.Code == "assembly-solid-volume-interference");
    }

    [Fact]
    public void SpecificationAndSharedRecipeEditsInvalidate()
    {
        using var session = new FirmamentCompilationSession();
        Good(session.Compile(Source()));
        var arguments = Good(session.Compile(Source(height: "3mm")));
        Assert.Equal(1, arguments.Reuse!.RebuiltDefinitions);
        var recipe = Good(session.Compile(Source(height: "3mm").Replace("10mm", "12mm")));
        Assert.Equal(1, recipe.Reuse!.RebuiltDefinitions);
        Assert.Equal("definition-inputs-changed", recipe.Reuse.Definitions.Single().Reason);
    }

    [Fact]
    public void ReturnedMutableGeometryAndEvidenceCannotPoisonTheCache()
    {
        using var session = new FirmamentCompilationSession();
        var first = Good(session.Compile(Source()));
        var body = first.Geometry!.DefinitionBodies.Values.Single();
        var before = body.Topology.Vertices.Count();
        body.Topology.AddVertex(new Vertex(new VertexId(999999)));
        first.Geometry.Artifact.Definitions.Single().Metrics.Minimum[0] = 999999;
        var next = Good(session.Compile(Source()));
        Assert.Equal(1, next.Reuse!.ReusedDefinitions);
        Assert.Equal(before, next.Geometry!.DefinitionBodies.Values.Single().Topology.Vertices.Count());
        Assert.NotEqual(999999, next.Geometry.Artifact.Definitions.Single().Metrics.Minimum[0]);
    }

    [Fact]
    public void FailedBuildIsNotCachedAndClearAndDisposeAreExplicit()
    {
        using var session = new FirmamentCompilationSession();
        var bad = Source(height: "-2mm");
        Assert.False(session.Compile(bad).IsSuccess);
        Assert.False(session.Compile(bad).IsSuccess);
        var fixedBuild = Good(session.Compile(Source()));
        Assert.Equal(1, fixedBuild.Reuse!.RebuiltDefinitions);
        session.Clear();
        Assert.Equal(1, Good(session.Compile(Source())).Reuse!.RebuiltDefinitions);
        session.Dispose();
        Assert.Throws<ObjectDisposedException>(() => session.Compile(Source()));
    }

    [Fact]
    public void CapacityEvictsDefinitionsWithoutChangingCorrectness()
    {
        using var session = new FirmamentCompilationSession(1);
        Good(session.Compile(Source()));
        Good(session.Compile(Source(height: "3mm")));
        Assert.Equal(1, Good(session.Compile(Source())).Reuse!.RebuiltDefinitions);
    }

    [Fact]
    public void SnapshotChangesAndMissingDocumentsCannotReuseStaleGeometry()
    {
        using var session = new FirmamentCompilationSession();
        FirmamentProjectSnapshot Project(string recipe) => new("main.firmasm", [
            KeyValuePair.Create("main.firmasm", "Include \"part.firmament\";\n" + Source()[Recipe.Length..]),
            KeyValuePair.Create("part.firmament", recipe)]);
        Good(session.CompileProject(Project(Recipe)));
        Assert.Equal(1, Good(session.CompileProject(Project(Recipe))).Reuse!.ReusedDefinitions);
        Assert.Equal(1, Good(session.CompileProject(Project(Recipe.Replace("10mm", "12mm")))).Reuse!.RebuiltDefinitions);
        var missing = new FirmamentProjectSnapshot("main.firmasm", [KeyValuePair.Create("main.firmasm", "Include \"part.firmament\";\n" + Source()[Recipe.Length..])]);
        var failed = session.CompileProject(missing);
        Assert.False(failed.IsSuccess);
        Assert.Empty(failed.Reuse!.Definitions);
    }

    [Fact]
    public void GuitarFileEditInvalidatesOnlyItsFileBackedDefinition()
    {
        var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm");
        var directory = Path.GetDirectoryName(path)!;
        var documents = Directory.GetFiles(directory, "*.firmament").Append(path)
            .Select(p => KeyValuePair.Create(Path.GetFileName(p), File.ReadAllText(p))).ToDictionary(p => p.Key, p => p.Value);
        using var session = new FirmamentCompilationSession();
        FirmamentProjectSnapshot Project() => new("guitar.firmasm", documents);
        var first = Good(session.CompileProject(Project()));
        var repeated = Good(session.CompileProject(Project()));
        Assert.Equal(56, repeated.Reuse!.ReusedDefinitions);
        Assert.Equal(AssemblyUsdExporter.Serialize(first.Ir!, AssemblyDisplayMeshExporter.Export(first)),
            AssemblyUsdExporter.Serialize(repeated.Ir!, AssemblyDisplayMeshExporter.Export(repeated)));
        var neckFile = documents.Keys.Single(k => k == "Neck.firmament");
        Assert.Contains("Depth: 40mm", documents[neckFile], StringComparison.Ordinal);
        documents[neckFile] = documents[neckFile].Replace("Depth: 40mm", "Depth: 39.8mm");
        var edited = Good(session.CompileProject(Project()));
        Assert.Equal(55, edited.Reuse!.ReusedDefinitions);
        Assert.Equal(1, edited.Reuse.RebuiltDefinitions);
        Assert.Contains(edited.Reuse.Definitions, d => !d.Reused && d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal));
        Assert.NotEqual(first.Geometry!.Artifact.Definitions.Single(d => d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal)).StepSha256,
            edited.Geometry!.Artifact.Definitions.Single(d => d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal)).StepSha256);
    }
}