Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Firmament M7a placement syntax parse and validation for primitives

Yuechen Lide3da3ab23fc
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
new file mode 100644
index 00000000..7075e35d
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPlacementValidationTests.cs
@@ -0,0 +1,120 @@
+using Aetheris.Kernel.Firmament.Diagnostics;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class FirmamentPlacementValidationTests
+{
+ [Fact]
+ public void Primitive_Without_Place_Remains_Valid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m3c-valid-box-exec.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Primitive_With_Origin_Place_Is_Valid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Primitive_With_SelectorShaped_PlaceAnchor_Is_Valid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-valid-box-selector-placement.firmament");
+ Assert.True(result.Compilation.IsSuccess);
+ }
+
+ [Fact]
+ public void Primitive_With_Place_Missing_On_Is_Invalid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-invalid-box-placement-missing-on.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.PlacementMissingRequiredField.Value, diagnostic.Message, StringComparison.Ordinal);
+ Assert.Contains("'place.on'", diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Primitive_With_Place_Missing_Offset_Is_Invalid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-invalid-box-placement-missing-offset.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.PlacementMissingRequiredField.Value, diagnostic.Message, StringComparison.Ordinal);
+ Assert.Contains("'place.offset'", diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Primitive_With_Place_Invalid_Anchor_Is_Invalid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-invalid-box-placement-invalid-anchor.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.PlacementInvalidAnchorShape.Value, diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Primitive_With_Place_Invalid_Offset_Length_Is_Invalid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-invalid-box-placement-offset-length.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.PlacementInvalidOffsetShape.Value, diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Primitive_With_Place_NonNumeric_Offset_Component_Is_Invalid()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7a-invalid-box-placement-offset-non-numeric.firmament");
+
+ Assert.False(result.Compilation.IsSuccess);
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains(FirmamentDiagnosticCodes.PlacementInvalidOffsetValue.Value, diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Placement_Declarations_Do_Not_Change_Primitive_Execution_Output()
+ {
+ var baseline = CompileFixture("testdata/firmament/fixtures/m3c-valid-box-exec.firmament");
+ var withPlacement = CompileFixture("testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament");
+
+ Assert.True(baseline.Compilation.IsSuccess);
+ Assert.True(withPlacement.Compilation.IsSuccess);
+
+ var basePrimitive = Assert.Single(baseline.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+ var placedPrimitive = Assert.Single(withPlacement.Compilation.Value.PrimitiveExecutionResult!.ExecutedPrimitives);
+
+ Assert.Equal(basePrimitive.Kind, placedPrimitive.Kind);
+ Assert.Equal(basePrimitive.FeatureId, placedPrimitive.FeatureId);
+ Assert.Equal(basePrimitive.Body.Topology.Faces.Count(), placedPrimitive.Body.Topology.Faces.Count());
+ Assert.Equal(basePrimitive.Body.Topology.Edges.Count(), placedPrimitive.Body.Topology.Edges.Count());
+ }
+
+ [Fact]
+ public void Placement_Diagnostics_Are_Deterministic()
+ {
+ var fixture = "testdata/firmament/fixtures/m7a-invalid-box-placement-missing-on.firmament";
+ var first = CompileFixture(fixture);
+ var second = CompileFixture(fixture);
+
+ Assert.False(first.Compilation.IsSuccess);
+ Assert.False(second.Compilation.IsSuccess);
+
+ var firstDiagnostic = Assert.Single(first.Compilation.Diagnostics);
+ var secondDiagnostic = Assert.Single(second.Compilation.Diagnostics);
+ Assert.Equal(firstDiagnostic.Message, secondDiagnostic.Message);
+ Assert.Equal(firstDiagnostic.Code, secondDiagnostic.Code);
+ }
+
+ private static FirmamentCompileResult CompileFixture(string fixturePath)
+ {
+ var source = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
+ var compiler = new FirmamentCompiler();
+ return compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(source)));
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
index b2ce9732..2a5b0641 100644
--- a/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
+++ b/Aetheris.Kernel.Firmament/Diagnostics/FirmamentDiagnosticCodes.cs
@@ -24,6 +24,11 @@ public static class FirmamentDiagnosticCodes
public static readonly FirmamentDiagnosticCode ValidationInvalidFieldValue = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0016");
public static readonly FirmamentDiagnosticCode ValidationInvalidTargetShape = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0017");
+ public static readonly FirmamentDiagnosticCode PlacementMissingRequiredField = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0019");
+ public static readonly FirmamentDiagnosticCode PlacementInvalidAnchorShape = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0020");
+ public static readonly FirmamentDiagnosticCode PlacementInvalidOffsetShape = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0021");
+ public static readonly FirmamentDiagnosticCode PlacementInvalidOffsetValue = new($"{FirmamentDiagnosticConventions.StructurePrefix}-0022");
+
public static readonly FirmamentDiagnosticCode ReferenceDuplicateFeatureId = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0001");
public static readonly FirmamentDiagnosticCode ReferenceUnknownFeatureId = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0002");
public static readonly FirmamentDiagnosticCode ValidationTargetUnknownFeatureId = new($"{FirmamentDiagnosticConventions.ReferencePrefix}-0003");
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
index cf1863c0..a7ef8f5d 100644
--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedDocument.cs
@@ -18,4 +18,5 @@ public sealed record FirmamentParsedOpEntry(
FirmamentKnownOpKind KnownKind,
FirmamentOpFamily Family,
IReadOnlyDictionary<string, string> RawFields,
+ FirmamentParsedPlacement? Placement = null,
IReadOnlyDictionary<string, string>? ClassifiedFields = null);
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPlacement.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPlacement.cs
new file mode 100644
index 00000000..dcb28191
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPlacement.cs
@@ -0,0 +1,11 @@
+namespace Aetheris.Kernel.Firmament.ParsedModel;
+
+public sealed record FirmamentParsedPlacement(
+ FirmamentParsedPlacementAnchor On,
+ IReadOnlyList<double> Offset);
+
+public abstract record FirmamentParsedPlacementAnchor;
+
+public sealed record FirmamentParsedPlacementOriginAnchor : FirmamentParsedPlacementAnchor;
+
+public sealed record FirmamentParsedPlacementSelectorAnchor(string Selector) : FirmamentParsedPlacementAnchor;
diff --git a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
index 063e9082..2d58d9bb 100644
--- a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
+++ b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
@@ -1,3 +1,4 @@
+using System.Globalization;
using System.Linq;
using System.Text.Json;
using Aetheris.Kernel.Core.Diagnostics;
@@ -246,7 +247,8 @@ internal static class FirmamentTopLevelParser
}
var family = FirmamentKnownOpKinds.ClassifyFamily(knownKind);
- entries.Add(new FirmamentParsedOpEntry(opName, knownKind, family, rawFields));
+ var placement = ParsePlacementFromJson(opElement);
+ entries.Add(new FirmamentParsedOpEntry(opName, knownKind, family, rawFields, placement));
index++;
}
@@ -280,7 +282,8 @@ internal static class FirmamentTopLevelParser
}
var family = FirmamentKnownOpKinds.ClassifyFamily(knownKind);
- entries.Add(new FirmamentParsedOpEntry(opName, knownKind, family, new Dictionary<string, string>(opEntry.Fields, StringComparer.Ordinal)));
+ var placement = ParsePlacementFromToon(opEntry);
+ entries.Add(new FirmamentParsedOpEntry(opName, knownKind, family, new Dictionary<string, string>(opEntry.Fields, StringComparer.Ordinal), placement));
}
return KernelResult<IReadOnlyList<FirmamentParsedOpEntry>>.Success(entries);
@@ -527,6 +530,159 @@ internal static class FirmamentTopLevelParser
&& int.TryParse(countText, out _);
}
+ private static FirmamentParsedPlacement? ParsePlacementFromJson(JsonElement opElement)
+ {
+ if (!opElement.TryGetProperty("place", out var placeElement))
+ {
+ return null;
+ }
+
+ if (placeElement.ValueKind != JsonValueKind.Object)
+ {
+ return null;
+ }
+
+ var anchor = default(FirmamentParsedPlacementAnchor);
+ if (placeElement.TryGetProperty("on", out var onElement))
+ {
+ var onRaw = onElement.ToString();
+ anchor = string.Equals(onRaw, "origin", StringComparison.Ordinal)
+ ? (FirmamentParsedPlacementAnchor)new FirmamentParsedPlacementOriginAnchor()
+ : new FirmamentParsedPlacementSelectorAnchor(onRaw);
+ }
+
+ var offset = new List<double>();
+ if (placeElement.TryGetProperty("offset", out var offsetElement)
+ && offsetElement.ValueKind == JsonValueKind.Array)
+ {
+ foreach (var component in offsetElement.EnumerateArray())
+ {
+ if (component.ValueKind == JsonValueKind.Number)
+ {
+ offset.Add(component.GetDouble());
+ }
+ }
+ }
+
+ if (anchor is null)
+ {
+ return null;
+ }
+
+ return new FirmamentParsedPlacement(anchor, offset);
+ }
+
+ private static FirmamentParsedPlacement? ParsePlacementFromToon(FirmamentToonObjectEntry opEntry)
+ {
+ if (!opEntry.Fields.TryGetValue("place", out var placeRaw) || string.IsNullOrWhiteSpace(placeRaw))
+ {
+ return null;
+ }
+
+ var trimmed = placeRaw.Trim();
+ if (!trimmed.StartsWith("{", StringComparison.Ordinal) || !trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ return null;
+ }
+
+ var body = trimmed[1..^1].Trim();
+ var pairs = SplitTopLevelCommaSeparated(body);
+ string? on = null;
+ var offset = new List<double>();
+
+ foreach (var pair in pairs)
+ {
+ var separator = pair.IndexOf(':');
+ if (separator <= 0)
+ {
+ continue;
+ }
+
+ var keyRaw = pair[..separator].Trim();
+ var key = TryParseArrayHeader(keyRaw, out var normalizedFieldName) ? normalizedFieldName : keyRaw;
+ var value = pair[(separator + 1)..].Trim();
+ if (string.Equals(key, "on", StringComparison.Ordinal))
+ {
+ on = value;
+ continue;
+ }
+
+ if (string.Equals(key, "offset", StringComparison.Ordinal)
+ && value.StartsWith("[", StringComparison.Ordinal)
+ && value.EndsWith("]", StringComparison.Ordinal))
+ {
+ var rawParts = value[1..^1].Split(',', StringSplitOptions.TrimEntries);
+ foreach (var part in rawParts)
+ {
+ if (double.TryParse(part, NumberStyles.Float, CultureInfo.InvariantCulture, out var component))
+ {
+ offset.Add(component);
+ }
+ }
+ }
+ }
+
+ if (string.IsNullOrWhiteSpace(on))
+ {
+ return null;
+ }
+
+ var anchor = string.Equals(on, "origin", StringComparison.Ordinal)
+ ? (FirmamentParsedPlacementAnchor)new FirmamentParsedPlacementOriginAnchor()
+ : new FirmamentParsedPlacementSelectorAnchor(on);
+
+ return new FirmamentParsedPlacement(anchor, offset);
+ }
+
+ private static IReadOnlyList<string> SplitTopLevelCommaSeparated(string raw)
+ {
+ var parts = new List<string>();
+ var start = 0;
+ var squareDepth = 0;
+ var curlyDepth = 0;
+
+ for (var i = 0; i < raw.Length; i++)
+ {
+ var ch = raw[i];
+ switch (ch)
+ {
+ case '[':
+ squareDepth++;
+ break;
+ case ']':
+ squareDepth = Math.Max(0, squareDepth - 1);
+ break;
+ case '{':
+ curlyDepth++;
+ break;
+ case '}':
+ curlyDepth = Math.Max(0, curlyDepth - 1);
+ break;
+ case ',':
+ if (squareDepth == 0 && curlyDepth == 0)
+ {
+ var part = raw[start..i].Trim();
+ if (part.Length > 0)
+ {
+ parts.Add(part);
+ }
+
+ start = i + 1;
+ }
+
+ break;
+ }
+ }
+
+ var finalPart = raw[start..].Trim();
+ if (finalPart.Length > 0)
+ {
+ parts.Add(finalPart);
+ }
+
+ return parts;
+ }
+
private static bool IsValidOpScalar(JsonElement opNameElement)
{
return opNameElement.ValueKind switch
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
index 4b451f02..56765add 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentPrimitiveRequiredFieldValidator.cs
@@ -1,4 +1,5 @@
using System.Globalization;
+using System.Linq;
using System.Text.Json;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Results;
@@ -68,6 +69,12 @@ internal static class FirmamentPrimitiveRequiredFieldValidator
}
}
+ var placementResult = ValidatePlacement(entry, opIndex);
+ if (!placementResult.IsSuccess)
+ {
+ return placementResult;
+ }
+
return KernelResult<bool>.Success(true);
}
@@ -90,6 +97,12 @@ internal static class FirmamentPrimitiveRequiredFieldValidator
return heightResult;
}
+ var placementResult = ValidatePlacement(entry, opIndex);
+ if (!placementResult.IsSuccess)
+ {
+ return placementResult;
+ }
+
return KernelResult<bool>.Success(true);
}
@@ -106,9 +119,143 @@ internal static class FirmamentPrimitiveRequiredFieldValidator
return radiusResult;
}
+ var placementResult = ValidatePlacement(entry, opIndex);
+ if (!placementResult.IsSuccess)
+ {
+ return placementResult;
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ private static KernelResult<bool> ValidatePlacement(FirmamentParsedOpEntry entry, int opIndex)
+ {
+ if (!entry.RawFields.ContainsKey("place"))
+ {
+ return KernelResult<bool>.Success(true);
+ }
+
+ entry.RawFields.TryGetValue("place", out var placeRaw);
+ var hasOn = false;
+ var hasOffset = false;
+ TryReadPlacementFieldPresence(placeRaw ?? string.Empty, out hasOn, out hasOffset);
+
+ if (!hasOn)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Primitive op '{entry.OpName}' at index {opIndex} is missing required field 'place.on'.")]);
+ }
+
+ if (!hasOffset)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Primitive op '{entry.OpName}' at index {opIndex} is missing required field 'place.offset'.")]);
+ }
+
+ if (entry.Placement is null)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementMissingRequiredField,
+ $"Primitive op '{entry.OpName}' at index {opIndex} has invalid field 'place'; expected object-like placement block with required fields 'on' and 'offset'.")]);
+ }
+
+ if (entry.Placement.On is FirmamentParsedPlacementSelectorAnchor selectorAnchor)
+ {
+ if (!FirmamentValidationTargetClassifier.TryClassify(selectorAnchor.Selector, out var shape)
+ || shape != FirmamentValidationTargetShape.SelectorShaped)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidAnchorShape,
+ $"Primitive op '{entry.OpName}' at index {opIndex} has invalid placement anchor in field 'place.on'; expected 'origin' or selector-shaped token 'feature.port'.")]);
+ }
+ }
+ else if (entry.Placement.On is not FirmamentParsedPlacementOriginAnchor)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidAnchorShape,
+ $"Primitive op '{entry.OpName}' at index {opIndex} has invalid placement anchor in field 'place.on'; expected 'origin' or selector-shaped token 'feature.port'.")]);
+ }
+
+ if (entry.RawFields.TryGetValue("place", out var placeRawForOffset)
+ && TryReadOffsetRawTokens(placeRawForOffset, out var offsetTokens)
+ && offsetTokens.Count == 3
+ && offsetTokens.Any(token => !TryParseNumeric(token, out _)))
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidOffsetValue,
+ $"Primitive op '{entry.OpName}' at index {opIndex} has invalid field 'place.offset' value; all components must be numeric.")]);
+ }
+
+ if (entry.Placement.Offset.Count != 3)
+ {
+ return KernelResult<bool>.Failure([
+ CreateDiagnostic(
+ FirmamentDiagnosticCodes.PlacementInvalidOffsetShape,
+ $"Primitive op '{entry.OpName}' at index {opIndex} has invalid field 'place.offset'; expected exactly 3 numeric components.")]);
+ }
+
return KernelResult<bool>.Success(true);
}
+ private static bool TryReadPlacementFieldPresence(string placeRaw, out bool hasOn, out bool hasOffset)
+ {
+ hasOn = false;
+ hasOffset = false;
+
+ var trimmed = placeRaw.Trim();
+ if (!trimmed.StartsWith("{", StringComparison.Ordinal) || !trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ return false;
+ }
+
+ hasOn = trimmed.Contains("on:", StringComparison.Ordinal);
+ hasOffset = trimmed.Contains("offset:", StringComparison.Ordinal)
+ || trimmed.Contains("offset[", StringComparison.Ordinal);
+ return true;
+ }
+
+ private static bool TryReadOffsetRawTokens(string placeRaw, out List<string> tokens)
+ {
+ tokens = [];
+ var trimmed = placeRaw.Trim();
+
+ if (trimmed.StartsWith("{", StringComparison.Ordinal) && trimmed.EndsWith("}", StringComparison.Ordinal))
+ {
+ var offsetKeyIndex = trimmed.IndexOf("offset", StringComparison.Ordinal);
+ if (offsetKeyIndex < 0)
+ {
+ return false;
+ }
+
+ var offsetSeparator = trimmed.IndexOf(':', offsetKeyIndex);
+ if (offsetSeparator < 0)
+ {
+ return false;
+ }
+
+ var bracketStart = trimmed.IndexOf('[', offsetSeparator + 1);
+ var bracketEnd = trimmed.IndexOf(']', bracketStart + 1);
+ if (bracketStart < 0 || bracketEnd <= bracketStart)
+ {
+ return false;
+ }
+
+ var content = trimmed[(bracketStart + 1)..bracketEnd];
+ tokens = content.Split(',', StringSplitOptions.TrimEntries).ToList();
+ return true;
+ }
+
+ return false;
+ }
+
private static bool TryGetRequiredNonEmptyScalar(FirmamentParsedOpEntry entry, string fieldName, int opIndex, out KernelDiagnostic? diagnostic)
{
diagnostic = null;
diff --git a/testdata/firmament/fixtures/m7a-invalid-box-placement-invalid-anchor.firmament b/testdata/firmament/fixtures/m7a-invalid-box-placement-invalid-anchor.firmament
new file mode 100644
index 00000000..c51e18d8
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-invalid-box-placement-invalid-anchor.firmament
@@ -0,0 +1,21 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_invalid_box_placement_invalid_anchor
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: base.top.face
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-offset.firmament b/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-offset.firmament
new file mode 100644
index 00000000..99999d88
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-offset.firmament
@@ -0,0 +1,17 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_invalid_box_placement_missing_offset
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: origin
diff --git a/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-on.firmament b/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-on.firmament
new file mode 100644
index 00000000..7eda25bd
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-invalid-box-placement-missing-on.firmament
@@ -0,0 +1,20 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_invalid_box_placement_missing_on
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-length.firmament b/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-length.firmament
new file mode 100644
index 00000000..a01d0ecc
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-length.firmament
@@ -0,0 +1,20 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_invalid_box_placement_offset_length
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: origin
+ offset[2]:
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-non-numeric.firmament b/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-non-numeric.firmament
new file mode 100644
index 00000000..2141f522
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-invalid-box-placement-offset-non-numeric.firmament
@@ -0,0 +1,21 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_invalid_box_placement_offset_non_numeric
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: origin
+ offset[3]:
+ 0
+ nope
+ 0
diff --git a/testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament b/testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament
new file mode 100644
index 00000000..8e6f4dde
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-valid-box-origin-placement.firmament
@@ -0,0 +1,21 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_valid_box_origin_placement
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: origin
+ offset[3]:
+ 0
+ 0
+ 0
diff --git a/testdata/firmament/fixtures/m7a-valid-box-selector-placement.firmament b/testdata/firmament/fixtures/m7a-valid-box-selector-placement.firmament
new file mode 100644
index 00000000..d941de49
--- /dev/null
+++ b/testdata/firmament/fixtures/m7a-valid-box-selector-placement.firmament
@@ -0,0 +1,28 @@
+firmament:
+ version: 1
+
+model:
+ name: m7a_valid_box_selector_placement
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: prior
+ size[3]:
+ 1
+ 1
+ 1
+ -
+ op: box
+ id: base
+ size[3]:
+ 10
+ 20
+ 30
+ place:
+ on: prior.top_face
+ offset[3]:
+ 0
+ 0
+ 0