Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

19.2 KB
Raw Blame
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Kernel.Firmament.Scene;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentInventoryTests
{
    private const string Bracket = "Record Spec { width: Length } Static spec: Spec = Spec { width: 30mm } Model Bracket { units: mm Box stock { size: [spec.width,20mm,6mm] } }";
    private const string Root = """
        Inventory Record Components { bracket: Part = Firmament("parts/bracket").Bracket }
        Assembly Machine {
          <Assembly Machine>
            <Part Left = Components.bracket> Placement { from: Origin; to: World; } </Part>
            <Part Right = Components.bracket> Placement { from: Origin; to: World; translateLocal: [50mm,0mm,0mm]; } </Part>
          </Assembly>
          Anchor: Machine;
        }
        """;
    private static FirmamentProjectSnapshot Project(string root = Root, params KeyValuePair<string,string>[] extra) =>
        new("main.firmasm", new[] { KeyValuePair.Create("main.firmasm",root),KeyValuePair.Create("parts/bracket.firmament",Bracket) }.Concat(extra));
    private static void Accepted(AssemblyM1CompilationResult result) => Assert.True(result.IsSuccess,string.Join("\n",result.Diagnostics.Select(d => d.Code+": "+d.Message)));

    [Fact]
    public void ExtensionlessPartUsesOneDefinitionAndPreservesConcreteGeometry()
    {
        var result=new AssemblyM1Pipeline().CompileProject(Project()); Accepted(result);
        var bodies=result.Geometry!.InstanceBodies.Values.ToArray(); Assert.Equal(2,bodies.Length);
        Assert.Single(result.Geometry.DefinitionBodies);
        var metric=Assert.Single(result.Geometry.Artifact.Definitions).Metrics;
        Assert.Equal(new[] { -15d,-10,0 },metric.Minimum);
        Assert.Equal(new[] { 15d,10,6 },metric.Maximum);
        Assert.Contains(result.Ir!.SourceDependencies!,d => d.Path=="parts/bracket.firmament");
    }

    [Fact]
    public void IdenticallyNamedExportsKeepTheirModuleSchemasAndPrivateValues()
    {
        var root=Root.Replace("bracket: Part = Firmament(\"parts/bracket\").Bracket", "bracket: Part = Firmament(\"parts/bracket\").Bracket other: Part = Firmament(\"parts/other\").Bracket")
            .Replace("Right = Components.bracket","Right = Components.other");
        var result=new AssemblyM1Pipeline().CompileProject(Project(root,
            KeyValuePair.Create("parts/other.firmament","Record Spec { width: Length thickness: Length } Static spec: Spec = Spec { width: 40mm thickness: 9mm } Model Bracket { units: mm Box stock { size: [spec.width,20mm,spec.thickness] } }")));
        Accepted(result); Assert.Equal(2,result.Geometry!.DefinitionBodies.Count);
        Assert.Contains(result.Geometry.Artifact.Definitions,d => d.Metrics.Maximum[0]==20 && d.Metrics.Maximum[2]==9);
    }

    [Theory]
    [InlineData("bracket: Scene = Firmament(\"parts/bracket\").Bracket","firmament-inventory-kind-mismatch")]
    [InlineData("bracket: Part = Firmament(\"parts/bracket\").Missing","firmament-inventory-export-unresolved")]
    [InlineData("bracket: Part = Firmament(\"parts/missing\").Bracket","assembly-include-file-not-found")]
    [InlineData("bracket: Part = Unknown(\"parts/bracket\")","firmament-inventory-resource-invalid")]
    [InlineData("bracket: Part = Step(\"bearing\")","assembly-include-file-not-found")]
    [InlineData("bracket: Part = Firmament(\"parts/bracket\").Bracket bracket: Part = Firmament(\"parts/bracket\").Bracket","firmament-inventory-duplicate-field")]
    public void InvalidEntriesRejectAtTheirAuthoredField(string field,string code)
    {
        var source="Inventory Record Components { "+field+" } Assembly Machine { <Assembly Machine></Assembly> Anchor: Machine; }";
        var result=new AssemblyM1Pipeline().CompileProject(Project(source));
        Assert.False(result.IsSuccess); Assert.Null(result.Geometry);
        Assert.Contains(result.Diagnostics,d => d.Code==code && d.SourceSpan?.Source=="main.firmasm" && d.SourceSpan.Length>0);
    }

    [Fact]
    public void AmbiguousExtensionlessLocatorRejectsRatherThanChoosingAFile()
    {
        var result=new AssemblyM1Pipeline().CompileProject(Project(Root,KeyValuePair.Create("parts/bracket.firmasm",Bracket)));
        Assert.False(result.IsSuccess); Assert.Contains(result.Diagnostics,d => d.Code=="firmament-module-locator-ambiguous");
    }

    [Fact]
    public void SubassemblyAndAssemblyImportsRetainTheirLocallySolvedProductTrees()
    {
        foreach(var kind in new[] {"Subassembly","Assembly"})
        {
            var child=Root.Replace("parts/bracket","bracket").Replace("Machine","Drive");
            if(kind=="Subassembly") child=child.Replace("Assembly Drive {", "Subassembly Drive {");
            var root=$$"""
                Inventory Record Components { drive: {{kind}} = Firmament("parts/drive").Drive }
                Assembly Machine { <Assembly Machine><Assembly Unit = Components.drive></Assembly></Assembly> Anchor: Machine.Unit; }
                """;
            var result=new AssemblyM1Pipeline().CompileProject(Project(root,KeyValuePair.Create("parts/drive.firmament",child)));
            Accepted(result); Assert.Equal(2,result.Geometry!.InstanceBodies.Count);
            Assert.Contains(result.Ir!.Instances,i => i.Path.ToString()=="Machine.Unit.Left");
        }
    }

    [Fact]
    public void SceneImportsPartAssemblyAndNestedSceneWithWorldPlacement()
    {
        const string child="Scene Workcell { units: mm <Part plate = Components.bracket> Placement { from: Origin; to: World; translateLocal: [20mm,0mm,0mm]; } </Part> }";
        const string root="""
            Inventory Record Library {
              part: Part = Firmament("parts/bracket").Bracket
              machine: Assembly = Firmament("machine").Machine
              cell: Scene = Firmament("cell").Workcell
            }
            Scene Factory { units: mm
              <Part stock = Library.part> Placement { from: Origin; to: World; } </Part>
              <Assembly machine = Library.machine> Placement { from: Origin; to: World; translateLocal: [100mm,0mm,0mm]; } </Assembly>
              <Scene cell = Library.cell> Placement { from: Origin; to: World; translateLocal: [200mm,0mm,0mm]; } </Scene>
            }
            """;
        var project=new FirmamentProjectSnapshot("scene.firmament",[
            KeyValuePair.Create("scene.firmament",root),KeyValuePair.Create("parts/bracket.firmament",Bracket),
            KeyValuePair.Create("machine.firmament",Root),KeyValuePair.Create("cell.firmament","Inventory Record Components { bracket: Part = Firmament(\"parts/bracket\").Bracket } "+child)]);
        using var session=new FirmamentSceneSession(); var result=session.CompileProject(project);
        Assert.True(result.IsSuccess,string.Join("\n",result.Diagnostics));
        Assert.Equal(-15,result.Scene!.MinimumMm[0]); Assert.Equal(235,result.Scene.MaximumMm[0]);
        Assert.Contains(result.Scene.Nodes,n => n.Path=="Factory.cell.plate" && n.Span.Source=="cell.firmament");
    }
    [Fact]
    public void RetainedPartCacheReusesAndInvalidatesTheActualModuleSource()
    {
        using var session=new FirmamentCompilationSession();
        var first=session.CompileProject(Project()); Accepted(first);
        var second=session.CompileProject(Project()); Accepted(second);
        Assert.True(Assert.Single(second.Reuse!.Definitions).Reused);
        var changed=new FirmamentProjectSnapshot("main.firmasm",[
            KeyValuePair.Create("main.firmasm",Root),KeyValuePair.Create("parts/bracket.firmament",Bracket.Replace("30mm","40mm"))]);
        var third=session.CompileProject(changed); Accepted(third);
        Assert.False(Assert.Single(third.Reuse!.Definitions).Reused);
        Assert.Equal(20,Assert.Single(third.Geometry!.Artifact.Definitions).Metrics.Maximum[0]);
    }

    [Fact]
    public void PublishedModulePortsParticipateInTheExistingMateSolver()
    {
        var part=Bracket.Replace(" } }", " } expose { Semantic Mount { DatumFrame Frame = [0,0,0] x [1,0,0] y [0,1,0] z [0,0,1]; } } }");
        var root=Root[..Root.IndexOf("Assembly Machine",StringComparison.Ordinal)]+"""
            Assembly Machine {
              <Assembly Machine><Part Left = Components.bracket></Part><Part Right = Components.bracket></Part></Assembly>
              Anchor: Machine.Left.Mount;
              Interface<Fixed> Installation { A: Machine.Left.Mount.Frame; B: Machine.Right.Mount.Frame; gap: 10mm; }
            }
            """;
        var project=new FirmamentProjectSnapshot("main.firmasm",[KeyValuePair.Create("main.firmasm",root),KeyValuePair.Create("parts/bracket.firmament",part)]);
        var result=new AssemblyM1Pipeline().CompileProject(project); Accepted(result);
        Assert.Equal(2,result.Geometry!.InstanceBodies.Count); Assert.Single(result.Ir!.Mates);
    }

    [Fact]
    public void InventoryShadowingIsLexicalAndSiblingInventoriesRemainPrivate()
    {
        var declaration="Inventory Record Components { bracket: Part = Firmament(\"parts/bracket\").Bracket }";
        var local="Inventory Record Components { bracket: Part = Firmament(\"parts/other\").Bracket }";
        var source=Root.Replace("Assembly Machine {", "Assembly Machine { "+local);
        var result=new AssemblyM1Pipeline().CompileProject(Project(source,KeyValuePair.Create("parts/other.firmament",Bracket.Replace("30mm","40mm"))));
        Accepted(result); Assert.Equal(20,Assert.Single(result.Geometry!.Artifact.Definitions).Metrics.Maximum[0]);
        var hidden="Subassembly Private { "+declaration+" <Assembly Private></Assembly> Anchor: Private; }\n"+Root.Replace(declaration,"");
        var rejected=new AssemblyM1Pipeline().CompileProject(Project(hidden));
        Assert.False(rejected.IsSuccess); Assert.Null(rejected.Geometry);
        Assert.Contains(rejected.Diagnostics,d => d.Code=="firmament-inventory-not-visible");
    }

    [Fact]
    public void InventoryDependencyCyclesAndIncludedSyntaxErrorsRetainTheirSourceFile()
    {
        var cyclic=Project(Root,KeyValuePair.Create("parts/other.firmament","Inventory Record Loop { root: Assembly = Firmament(\"../main\").Machine } Model Other { units: mm Box stock { size: [1mm,1mm,1mm] } }"));
        var root=Root.Replace("parts/bracket", "parts/other").Replace(".Bracket", ".Other");
        var result=new AssemblyM1Pipeline().CompileProject(new("main.firmasm",cyclic.Documents.Select(p => p.Key=="main.firmasm" ? KeyValuePair.Create(p.Key,root) : p)));
        Assert.Contains(result.Diagnostics,d => d.Code=="firmament-module-cycle" && d.SourceSpan?.Source=="parts/other.firmament");
        var invalid=new FirmamentProjectSnapshot("main.firmasm",[
            KeyValuePair.Create("main.firmasm","include \"parts/broken\";\nAssembly Root { <Assembly Root></Assembly> Anchor: Root; }"),
            KeyValuePair.Create("parts/broken.firmament","Record Broken { width: }")]);
        var syntax=new AssemblyM0Parser().ParseProject(invalid);
        Assert.False(syntax.IsSuccess); Assert.Contains(syntax.Diagnostics,d => d.SourceSpan?.Source=="parts/broken.firmament" && d.SourceSpan.Start>0);
    }

    [Theory]
    [InlineData("Inventory Things { }")]
    [InlineData("Inventory Record Things() { }")]
    [InlineData("Inventory<> Record Things { }")]
    [InlineData("Inventory Record Things<> { }")]
    [InlineData("Inventory Record Things { typo: Part = Step(\"anything\") extra: 3 }")]
    public void MalformedInventoriesCannotDisappear(string inventory)
    {
        var result=new AssemblyM1Pipeline().CompileProject(Project(inventory+"\nAssembly Root { <Assembly Root></Assembly> Anchor: Root; }"));
        Assert.False(result.IsSuccess); Assert.NotEmpty(result.Diagnostics);
    }

    [Fact]
    public void ATemplateMustBeSpecializedInsideItsDefiningModuleBeforeInventoryExport()
    {
        var library="Template<width: Length> Struct Bracket { Box stock { size: [width,20mm,6mm] } }";
        var project=new FirmamentProjectSnapshot("main.firmasm",[KeyValuePair.Create("main.firmasm",Root),KeyValuePair.Create("parts/bracket.firmament",library)]);
        var rejected=new AssemblyM1Pipeline().CompileProject(project);
        Assert.False(rejected.IsSuccess); Assert.Contains(rejected.Diagnostics,d => d.Code=="firmament-inventory-specialization-required");
        library=library.Replace("Struct Bracket", "Struct Family")+"\nStruct Bracket = Family<width: 30mm>";
        var accepted=new AssemblyM1Pipeline().CompileProject(new("main.firmasm",[KeyValuePair.Create("main.firmasm",Root),KeyValuePair.Create("parts/bracket.firmament",library)]));
        Accepted(accepted); Assert.Equal(15,Assert.Single(accepted.Geometry!.Artifact.Definitions).Metrics.Maximum[0]);
    }

    [Fact]
    public void FileBackedStepUsesTheExistingExactImporterAndContributesAHashedDependency()
    {
        var directory=Path.GetFullPath(Path.Combine(AppContext.BaseDirectory,"../../../../artifacts/local/firmament-inventory/step-"+Guid.NewGuid().ToString("N")));
        Directory.CreateDirectory(directory);
        try
        {
            // This adapter witness intentionally exports its own asymmetric Part, then
            // imports that exact artifact; it is not a second import of the shared corpus.
            var original=FirmamentBuildAndExport.CompileSource(Bracket); Assert.True(original.IsSuccess);
            File.WriteAllText(Path.Combine(directory,"bearing.step"),original.Value!.StepText);
            var source=Root.Replace("Firmament(\"parts/bracket\").Bracket", "Step(\"bearing\")");
            var path=Path.Combine(directory,"main.firmament"); File.WriteAllText(path,source);
            var built=new AssemblyM1Pipeline().CompileFile(path); Accepted(built);
            Assert.Equal(15,Assert.Single(built.Geometry!.Artifact.Definitions).Metrics.Maximum[0]);
            Assert.Contains(built.Ir!.SourceDependencies!,d => d.Path.EndsWith("bearing.step",StringComparison.Ordinal) && d.Sha256.Length==64);
        }
        finally { Directory.Delete(directory,true); }
    }

    [Fact]
    public void FileAndSnapshotProjectsHaveTheSameDefinitionIdentitiesAndGeometry()
    {
        var root=FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Regression/Inventory/machine.firmasm");
        var file=new AssemblyM1Pipeline().CompileFile(root); Accepted(file);
        var directory=Path.GetDirectoryName(root)!;
        var names=new[] {"machine.firmasm","drive.firmament","parts/bracket.firmament","parts/wide-bracket.firmament"};
        var snapshot=new AssemblyM1Pipeline().CompileProject(new("machine.firmasm",names.Select(name => KeyValuePair.Create(name,File.ReadAllText(Path.Combine(directory,name))))));
        Accepted(snapshot);
        // The overall artifact digest includes intentionally different file/snapshot
        // provenance. Compare the actual definition bytes and world geometry instead.
        Assert.Equal(file.Geometry!.DefinitionBodies.Keys.Order(),snapshot.Geometry!.DefinitionBodies.Keys.Order());
        Assert.Equal(file.Geometry.Artifact.Definitions.Select(d => d.StepSha256),snapshot.Geometry.Artifact.Definitions.Select(d => d.StepSha256));
        Assert.Equal(file.Geometry.Artifact.Instances.Select(i => string.Join(",",i.WorldTransform.Matrix)),snapshot.Geometry.Artifact.Instances.Select(i => string.Join(",",i.WorldTransform.Matrix)));
        Assert.Equal(4,file.Geometry.InstanceBodies.Count);
        Assert.Contains(file.Ir!.InventoryBindings,b => b.Name=="Components.drive" && b.Kind=="Subassembly");
    }

    [Fact]
    public void InvalidLocatorEscapesAreDiagnosticsRatherThanReaderExceptions()
    {
        var source=Root.Replace("parts/bracket",@"parts\q");
        var result=new AssemblyM1Pipeline().CompileProject(Project(source));
        Assert.False(result.IsSuccess); Assert.Contains(result.Diagnostics,d => d.Code=="firmament-module-locator-invalid");
    }

    [Fact]
    public void SnapshotCannotReadUnprovidedDiskAssetsThroughAnImportedPart()
    {
        const string part="Model Bracket { units: mm InlineStep source { path: \"C:/unavailable.step\" } }";
        var result=new AssemblyM1Pipeline().CompileProject(new("main.firmasm",[KeyValuePair.Create("main.firmasm",Root),KeyValuePair.Create("parts/bracket.firmament",part)]));
        Assert.False(result.IsSuccess);
        Assert.Contains(result.Diagnostics,d => d.Code=="assembly-include-outside-root" && d.SourceSpan?.Source=="parts/bracket.firmament");
    }

    [Fact]
    public void ShortIncludesComposeConcreteAndLegacyTemplatePartsWithoutCatalogAliases()
    {
        var path=FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Regression/Inventory/include-simple.firmament");
        var result=new AssemblyM1Pipeline().CompileFile(path); Accepted(result);
        Assert.Equal(2,result.Geometry!.InstanceBodies.Count); Assert.Equal(2,result.Geometry.DefinitionBodies.Count);
    }

    [Fact]
    public void ADeclarationOnlyInventoryModuleNamesItsRequiredConsumerRatherThanARecordHeaderError()
    {
        var source=File.ReadAllText(FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Regression/Inventory/drive.firmament"));
        var parsed=Aetheris.Kernel.Firmament.FirmamentV2.FirmamentV2Parser.Parse(source);
        Assert.False(parsed.IsSuccess);
        Assert.Contains(parsed.SyntaxDiagnostics,d => d.Code=="firmament-module-context-required" && d.SourceSpan is not null && d.Stage=="Module binding");
        Assert.False(FirmamentBuildAndExport.CompileSource(source).IsSuccess);
    }

    [Fact]
    public void AlreadyResolvedSourceRetainsItsExplicitProjectContext()
    {
        const string source="Assembly Root { <Assembly Root><Part Shade = SectionChainFile<\"shade.firmament\">></Part></Assembly> Anchor: Root.Shade; }";
        var project=new FirmamentProjectSnapshot("main.firmasm",[KeyValuePair.Create("main.firmasm",source),KeyValuePair.Create("shade.firmament",Bracket)]);
        var result=new AssemblyM0Parser().Parse(source,"main.firmasm",project);
        Assert.True(result.IsSuccess,string.Join("\n",result.Diagnostics));
        Assert.Contains(result.Source!.SourceDependencies!,d => d.Path=="shade.firmament");
    }

    [Fact]
    public void PatternOccurrencesBindInventoryBeforeExpansionAndProtectTheIterationName()
    {
        const string source="""
            Inventory Record Parts { bracket: Part = Firmament("parts/bracket").Bracket }
            Linear Sites Seats { keys: [Left,Right]; start: [0mm,0mm,0mm]; step: [50mm,0mm,0mm]; }
            Assembly Machine {
              <Assembly Machine>
                Pattern Mounts over Seats {
                  site => <Part Item = Parts.bracket>
                    Placement { from: Origin; to: World; translateLocal: [site.X,site.Y,site.Z]; }
                  </Part>
                }
              </Assembly>
              Anchor: Machine;
            }
            """;
        var result=new AssemblyM1Pipeline().CompileProject(Project(source)); Accepted(result);
        Assert.Equal(2,result.Geometry!.InstanceBodies.Count); Assert.Single(result.Geometry.DefinitionBodies);
        Assert.Contains(result.Ir!.Instances,i => i.Path.ToString()=="Machine.Mounts.Left.Item");
        var shadowed=source.Replace("site =>","Parts =>").Replace("site.X","Parts.X").Replace("site.Y","Parts.Y").Replace("site.Z","Parts.Z");
        var rejected=new AssemblyM1Pipeline().CompileProject(Project(shadowed));
        Assert.False(rejected.IsSuccess); Assert.Null(rejected.Geometry);
        Assert.Contains(rejected.Diagnostics,d => d.Code=="firmament-inventory-not-visible");
    }

}