Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

5.9 KB
Raw Blame
using Aetheris.Kernel.Firmament.Assembly;

namespace Aetheris.Kernel.Firmament.Tests.Assembly;

/// <summary>BUILD-PERF-M2: definitions compile from the declarations they depend on.</summary>
public sealed class AssemblyDeclarationScopeTests
{
    private const string Catalog = """
        Record Spec { Width: Length }
        Static Standard: Spec { Width: 4mm }
        Function twice(value: Length) -> Length =
          value * 2
        Template<H: Length> Struct Pad {
          Rect2 Outline { Center: [0mm,0mm]; Size: [twice(Standard.Width),10mm] }
          Profile P { Loop Outer { Outline |> TraceLoop } }
          Extrude Body { Profile: P From: 0mm To: H }
        }
        Template<R: Length> Struct Peg {
          Circle2 Outline { center: [0mm,0mm] radius: R }
          Profile P { Loop Outer { Outline |> TraceLoop } }
          Extrude Body { profile: P from: 0mm to: 5mm }
        }
        Concept Struct Layout {
          Axis Spindle { origin: [0mm, 0mm, 0mm]; direction: [0, 0, 1]; reference: [1, 0, 0]; }
        }
        """;

    [Fact]
    public void ClosureKeepsTransitiveDependenciesAndDropsUnrelatedDeclarations()
    {
        var pad = AssemblyDeclarationScope.Closure(Catalog, "Pad")!;
        Assert.Contains("Record Spec", pad, StringComparison.Ordinal);
        Assert.Contains("Static Standard", pad, StringComparison.Ordinal);
        // A multi-line expression stays with its declaration.
        Assert.Contains("value * 2", pad, StringComparison.Ordinal);
        Assert.DoesNotContain("Struct Peg", pad, StringComparison.Ordinal);
        Assert.DoesNotContain("Concept Struct Layout", pad, StringComparison.Ordinal);

        var peg = AssemblyDeclarationScope.Closure(Catalog, "Peg")!;
        Assert.Contains("Struct Peg", peg, StringComparison.Ordinal);
        Assert.DoesNotContain("Struct Pad", peg, StringComparison.Ordinal);
        Assert.DoesNotContain("Function twice", peg, StringComparison.Ordinal);

        Assert.Null(AssemblyDeclarationScope.Closure(Catalog, "Missing"));
    }

    [Fact]
    public void UnnamedDeclarationsFollowTheClosuresTheyMention()
    {
        var catalog = Catalog + "\nModify Pad {\n  Hole<Shaft> Bore { On: +Z Center: Point2(0mm, 0mm) Diameter: 2mm End: ThroughAll }\n}\n";
        Assert.Contains("Modify Pad", AssemblyDeclarationScope.Closure(catalog, "Pad")!, StringComparison.Ordinal);
        Assert.DoesNotContain("Modify Pad", AssemblyDeclarationScope.Closure(catalog, "Peg")!, StringComparison.Ordinal);
    }

    public static TheoryData<string> CanonicalAssemblies()
    {
        var data = new TheoryData<string>();
        var root = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces");
        // The guitar (56 definitions) is covered by the showcase hash budgets (Aetheris.Web.Perf).
        foreach (var file in Directory.GetFiles(root, "*.firm*", SearchOption.AllDirectories)
                     .Where(file => !file.Contains("GuitarX0", StringComparison.Ordinal)).Order(StringComparer.Ordinal))
            data.Add(Path.GetRelativePath(root, file).Replace('\\', '/'));
        return data;
    }

    [Theory]
    [MemberData(nameof(CanonicalAssemblies))]
    public void ScopedDeclarationsBuildTheSameAssemblyAsTheWholeCatalog(string fixture)
    {
        var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/" + fixture);
        var scoped = Compile(path, scope: true);
        var whole = Compile(path, scope: false);
        Assert.Equal(whole.IsSuccess, scoped.IsSuccess);
        if (!whole.IsSuccess) return;
        Assert.Equal(Codes(whole), Codes(scoped));
        Assert.Equal(Definitions(whole), Definitions(scoped));
        Assert.Equal(whole.Ir!.Instances.Select(i => (i.StableId, string.Join(',', i.ResolvedTransform?.Matrix ?? []))),
            scoped.Ir!.Instances.Select(i => (i.StableId, string.Join(',', i.ResolvedTransform?.Matrix ?? []))));
    }

    [Fact]
    public void IncludeEditInvalidatesOnlyTheDefinitionsThatUseIt()
    {
        var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/IndustrialAtlas/atlas-industrial.firmament");
        var directory = Path.GetDirectoryName(path)!;
        var documents = Directory.GetFiles(directory, "*.firmament")
            .ToDictionary(Path.GetFileName, file => File.ReadAllText(file).Replace("\r\n", "\n"), StringComparer.Ordinal)!;
        using var session = new FirmamentCompilationSession();
        FirmamentProjectSnapshot Project() => new("atlas-industrial.firmament", documents);
        var first = session.CompileProject(Project());
        Assert.True(first.IsSuccess, string.Join("\n", first.Diagnostics.Select(d => d.Message)));
        var gripper = documents["gripper.firmament"];
        documents["gripper.firmament"] = gripper + "\n// a comment only the gripper's definitions see\n";
        var edited = session.CompileProject(Project());
        Assert.True(edited.IsSuccess);
        Assert.True(edited.Reuse!.ReusedDefinitions > 0, "an edit to one include must not rebuild every definition");
        Assert.True(edited.Reuse.RebuiltDefinitions < edited.Reuse.Definitions.Count);
        var fresh = new AssemblyM1Pipeline().CompileProject(Project());
        Assert.Equal(Definitions(fresh), Definitions(edited));
    }

    private static AssemblyM1CompilationResult Compile(string path, bool scope)
    {
        AssemblyDefinitionMaterializer.ScopeDeclarations = scope;
        try { return new AssemblyM1Pipeline().CompileFile(path); }
        finally { AssemblyDefinitionMaterializer.ScopeDeclarations = true; }
    }

    private static string[] Codes(AssemblyM1CompilationResult result) =>
        result.Diagnostics.Select(d => d.Code).Order(StringComparer.Ordinal).ToArray();

    private static string[] Definitions(AssemblyM1CompilationResult result) =>
        result.Geometry!.Artifact.Definitions.Select(d => d.DefinitionIdentity + "=" + d.StepSha256).Order(StringComparer.Ordinal).ToArray();
}