using OpenNest.CNC; using OpenNest.CNC.CuttingStrategy; using OpenNest.Engine.Jobs; using OpenNest.Geometry; using OpenNest.IO; using OpenNest.Mcp; using OpenNest.Mcp.Tools; namespace OpenNest.FrontEnd.Tests; [Collection("FrontEndRegistry")] public class McpWholeJobTests : IDisposable { private readonly string directory = Path.Combine(Path.GetTempPath(), "opennest-mcp-job-" + Guid.NewGuid()); public McpWholeJobTests() => Directory.CreateDirectory(directory); public void Dispose() => Directory.Delete(directory, true); private static Drawing Square(string name, double size = 2) { var shape = new Shape(); shape.Entities.Add(new Line(new Vector(0, 0), new Vector(size, 0))); shape.Entities.Add(new Line(new Vector(size, 0), new Vector(size, size))); shape.Entities.Add(new Line(new Vector(size, size), new Vector(0, size))); shape.Entities.Add(new Line(new Vector(0, size), new Vector(0, 0))); return new Drawing(name, OpenNest.Converters.ConvertGeometry.ToProgram(shape)); } private static NestSession Session() { var session = new NestSession { Nest = new Nest("job") }; session.Nest.Drawings.Add(Square("A")); session.Nest.Drawings.Add(Square("B")); session.Nest.Plates.Add(new Plate(10, 10) { PartSpacing = 0.25, Quantity = 1 }); return session; } private static string Call(NestingTools tools, int plateIndex, string names, string quantities, string engine, bool noNew = false, CancellationToken token = default) => tools.AutoNestJob(plateIndex, names, quantities, engine, noNew, token); [Fact] public void AcceptedPricesAndRequirementsSurviveSaveWithoutLosingMetadata() { var session = Session(); session.Nest.Customer = "Cost customer"; session.Nest.Notes = "Keep these notes"; session.Nest.Units = Units.Inches; session.Nest.SalvageRate = 0.25; var output = new NestingTools(session).AutoNestJob(0, "A,B", "1,1", "Rectangles", sheets: [new SheetStockInput { Width = 10, Length = 10, Quantity = 2, Cost = 50 }, new SheetStockInput { Width = 12, Length = 12, Quantity = 2, Cost = 7 }]); Assert.Contains("Whole job complete", output); Assert.Contains("gross total=7", output); Assert.Contains("net score=7", output); Assert.Contains("supplied-cost", output); Assert.All(session.AllDrawings(), d => Assert.Equal(1, d.Quantity.Required)); var path = Path.Combine(directory, "priced.nest"); new InputTools(session).SaveNest(path); var reopened = new NestReader(path).Read(); Assert.Equal("Cost customer", reopened.Customer); Assert.Equal("Keep these notes", reopened.Notes); Assert.Equal(Units.Inches, reopened.Units); Assert.Equal(0.25, reopened.SalvageRate); Assert.Equal(new[] { 50d, 7d }, reopened.PlateOptions.Select(o => o.Cost)); Assert.All(reopened.Drawings, d => Assert.Equal(1, d.Quantity.Required)); Assert.Equal(2, reopened.Plates.Sum(p => p.Parts.Count)); } [Theory] [InlineData(null)] [InlineData(0d)] [InlineData(-1d)] [InlineData(double.NaN)] [InlineData(double.PositiveInfinity)] public void InvalidCostsDoNotMutateSession(double? cost) { var session = Session(); var quantities = session.AllDrawings().Select(d => d.Quantity.Required).ToArray(); var output = new NestingTools(session).AutoNestJob(0, "A,B", "1,1", "Rectangles", sheets: [new SheetStockInput { Width = 10, Length = 10, Quantity = 1, Cost = 5 }, new SheetStockInput { Width = 12, Length = 12, Quantity = 1, Cost = cost }]); Assert.Contains("Error:", output); Assert.Contains("sheets[1]", output); Assert.Empty(session.GetPlate(0).Parts); Assert.Empty(session.Nest.PlateOptions); Assert.Equal(quantities, session.AllDrawings().Select(d => d.Quantity.Required)); } [Fact] public void FiniteSheetInputsReachEngineWithTemplateSettings() { var session = Session(); var template = session.GetPlate(0); template.Size = new Size(60, 120); template.EdgeSpacing = new Spacing(1, 2, 3, 4); template.Quadrant = 3; var engine = "StockMap-" + Guid.NewGuid(); var called = false; NestingEngineRegistry.Register(engine, "inspect finite stock", () => new InspectStub(job => { called = true; Assert.Equal(2, job.Plates.Count); Assert.Equal(["stock-0", "stock-1"], job.Plates.Select(s => s.Id)); Assert.Equal([new Size(60, 120), new Size(48, 96)], job.Plates.Select(s => s.Size)); Assert.Equal([1, 2], job.Plates.Select(s => s.Quantity)); Assert.All(job.Plates, stock => { Assert.Equal(0.25, stock.PartSpacing); Assert.Equal(template.EdgeSpacing, stock.EdgeSpacing); Assert.Equal(3, stock.Quadrant); }); Assert.Equal(2, job.Options.MaxPlates); // capped by demand, not plate.Quantity return new NestJobResult(NestJobStatus.Incomplete, NestJobStopReason.StockExhausted, [], [], []); })); var rows = new[] { new SheetStockInput { Width = 60, Length = 120, Quantity = 1 }, new SheetStockInput { Width = 48, Length = 96, Quantity = 2 } }; var tool = new NestingTools(session); Assert.Contains("incomplete", tool.AutoNestJob(0, "A,B", "1,1", engine, sheets: rows)); Assert.True(called); called = false; rows[1].Width = double.NaN; Assert.Contains("sheets[1]", tool.AutoNestJob(0, "A,B", "1,1", engine, sheets: rows)); Assert.False(called); Assert.Single(session.AllPlates()); Assert.Empty(template.Parts); Assert.Equal(1, template.Quantity); // no inventory drawn from the template quantity } private sealed class InspectStub(Func solve) : INestingEngine { public NestJobResult Solve(NestJob job, IProgress? progress = null, CancellationToken token = default) => solve(job); } [Fact] public void FiniteMixedSheetsCommitByStockIdAndRoundTrip() { var session = Session(); var template = session.GetPlate(0); template.Size = new Size(6, 6); template.Quantity = 9; // repeat count is not inventory var small = session.Nest.Drawings.Single(d => d.Name == "B"); var large = Square("large", 4); // four-by-four cannot fit a three-by-three sheet session.Nest.Drawings.Add(large); var rows = new[] { new SheetStockInput { Width = 6, Length = 6, Quantity = 1 }, new SheetStockInput { Width = 3, Length = 3, Quantity = 2 } }; var engine = "MixedStock-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "two different sheets", () => new InspectStub(job => { Assert.Equal(2, job.Options.MaxPlates); Assert.Equal([1, 2], job.Plates.Select(s => s.Quantity)); // Small stock first: result ordinal must not resize/reuse the large template. return new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed, [new NestJobPlateResult(0, job.Plates[1], [new NestJobPlacement(job.Parts[1].Id, 0, 0.5, 0.5, 0)]), new NestJobPlateResult(1, job.Plates[0], [new NestJobPlacement(job.Parts[0].Id, 1, 0.5, 0.5, 0)])], [], []); })); var text = new NestingTools(session).AutoNestJob(0, "large,B", "1,1", engine, sheets: rows); Assert.Contains("Whole job complete", text); Assert.Contains("stock-0 (6x6): used=1, remaining=0, reused=1, created=0", text); Assert.Contains("stock-1 (3x3): used=1, remaining=1, reused=0, created=1", text); Assert.Contains("plate 0 -> stock-0", text); Assert.Contains("plate 1 -> stock-1", text); Assert.Same(template, session.GetPlate(0)); Assert.Equal(new Size(6, 6), template.Size); Assert.Same(large, Assert.Single(template.Parts).BaseDrawing); Assert.Same(small, Assert.Single(session.GetPlate(1).Parts).BaseDrawing); Assert.Equal(1, template.Quantity); var path = Path.Combine(directory, "mixed.nest"); Assert.Contains("Saved nest", new InputTools(session).SaveNest(path)); var reloaded = new NestReader(path).Read(); Assert.Equal([new Size(6, 6), new Size(3, 3)], reloaded.Plates.Select(p => p.Size)); Assert.All(reloaded.Plates, p => Assert.Equal(1, p.Quantity)); Assert.Equal(1, reloaded.Drawings.Single(d => d.Name == "large").Quantity.Nested); Assert.Equal(1, reloaded.Drawings.Single(d => d.Name == "B").Quantity.Nested); } [Fact] public void FiniteStockOverdrawIsRejectedBeforeAnySessionMutation() { var session = Session(); var plate = session.GetPlate(0); plate.Size = new Size(3, 3); var engine = "Overdraw-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "overdraw stock", () => new InspectStub(job => new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed, [new NestJobPlateResult(0, job.Plates[0], [new NestJobPlacement(job.Parts[0].Id, 0, 0.5, 0.5, 0)]), new NestJobPlateResult(1, job.Plates[0], [new NestJobPlacement(job.Parts[1].Id, 1, 0.5, 0.5, 0)])], [], []))); var text = new NestingTools(session).AutoNestJob(0, "A,B", "1,1", engine, sheets: [new SheetStockInput { Width = 3, Length = 3, Quantity = 1 }, new SheetStockInput { Width = 6, Length = 6, Quantity = 2 }]); Assert.Contains("stock-0", text); Assert.Contains("invalid", text, StringComparison.OrdinalIgnoreCase); Assert.Single(session.AllPlates()); Assert.Empty(plate.Parts); Assert.All(session.Nest.Drawings, d => Assert.Equal(0, d.Quantity.Nested)); } [Fact] public void FiniteStockRejectsInvalidInventoryBeforeSolving() { var session = Session(); var plate = session.GetPlate(0); var engine = "NeverSolve-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "should not be called", () => new InspectStub(_ => throw new Xunit.Sdk.XunitException("invalid input reached solver"))); var tools = new NestingTools(session); var valid = new SheetStockInput { Width = 10, Length = 10, Quantity = 1 }; Assert.Contains("at least one", tools.AutoNestJob(0, "A", "1", engine, sheets: [])); Assert.Contains("sheets[0]", tools.AutoNestJob(0, "A", "1", engine, sheets: [new SheetStockInput { Width = 10, Length = 10, Quantity = 0 }])); Assert.Contains("sheets[0]", tools.AutoNestJob(0, "A", "1", engine, sheets: [new SheetStockInput { Width = double.PositiveInfinity, Length = 10, Quantity = 1 }])); Assert.Contains("sheets[0]", tools.AutoNestJob(0, "A", "1", engine, sheets: [new SheetStockInput { Width = 0, Length = 10, Quantity = 1 }])); Assert.Contains("sheets[1] duplicates sheets[0]", tools.AutoNestJob(0, "A", "1", engine, sheets: [valid, new SheetStockInput { Width = 10, Length = 10, Quantity = 2 }])); Assert.Contains("sheet inventory exceeds", tools.AutoNestJob(0, "A", "1", engine, sheets: [new SheetStockInput { Width = 10, Length = 10, Quantity = int.MaxValue }, new SheetStockInput { Width = 11, Length = 11, Quantity = 1 }])); Assert.Contains("cannot be combined", tools.AutoNestJob(0, "A", "1", engine, no_new_plates: true, sheets: [valid])); Assert.Single(session.AllPlates()); Assert.Empty(plate.Parts); Assert.Equal(1, plate.Quantity); } [Fact] public void FiniteInventoryUsesOnlyOneOfTwoMatchingEmptySheets() { var session = Session(); var original = session.GetPlate(0); session.Plates.Add(new Plate(10, 10) { PartSpacing = 0.25, Quantity = 5 }); var text = new NestingTools(session).AutoNestJob(0, "A", "1", "Rectangles", sheets: [new SheetStockInput { Width = 10, Length = 10, Quantity = 1 }]); Assert.Contains("Whole job complete", text); Assert.Contains("stock-0 (10x10): used=1, remaining=0", text); Assert.Single(original.Parts); Assert.Empty(session.GetPlate(1).Parts); Assert.Equal(5, session.GetPlate(1).Quantity); } [Fact] public void LaterSelectedTemplateIsReusedBeforeOtherCompatibleEmptySheet() { var session = Session(); var earlier = session.GetPlate(0); var selected = new Plate(10, 10) { PartSpacing = 0.25, Quantity = 3 }; session.Plates.Add(selected); var text = new NestingTools(session).AutoNestJob(1, "A", "1", "Rectangles"); Assert.Contains("Whole job complete", text); Assert.Empty(earlier.Parts); Assert.Single(selected.Parts); Assert.Equal(1, selected.Quantity); } [Fact] public void CreatesSheetsForCompleteMixedJobThenSavesAndReloads() { var session = Session(); var original = session.GetPlate(0); var engine = "JobTwoSheets-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "two safe sheets", () => new TwoSheetStub()); var text = Call(new NestingTools(session), 0, "A,B", "2,2", engine); Assert.Contains("complete", text, StringComparison.OrdinalIgnoreCase); Assert.Single(session.AllPlates()); Assert.Same(original, session.GetPlate(0)); Assert.Empty(session.Plates); Assert.Equal(2, original.Parts.Count); Assert.Equal(0.25, original.PartSpacing); Assert.Equal(2, original.Quantity); Assert.Contains("2 sheet(s) placed in 1 layout(s)", text); Assert.Equal(2, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(2, session.Nest.Drawings.Single(d => d.Name == "B").Quantity.Nested); var path = Path.Combine(directory, "complete.nest"); Assert.Contains("Saved nest", new InputTools(session).SaveNest(path)); var loaded = new NestReader(path).Read(); Assert.Equal(2, Assert.Single(loaded.Plates).Quantity); Assert.Equal(2, loaded.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(2, loaded.Drawings.Single(d => d.Name == "B").Quantity.Nested); } [Fact] public void NoNewPlateFlagRefusesIncompleteProposalWithoutMutation() { var session = Session(); var original = session.GetPlate(0); var engine = "JobLimited-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "one sheet when capped", () => new TwoSheetStub()); var text = Call(new NestingTools(session), 0, "A,B", "2,2", engine, noNew: true); Assert.Contains("incomplete", text, StringComparison.OrdinalIgnoreCase); Assert.Contains("Nothing committed", text); Assert.Single(session.AllPlates()); Assert.Same(original, session.GetPlate(0)); Assert.Empty(original.Parts); Assert.All(session.Nest.Drawings, d => Assert.Equal(0, d.Quantity.Nested)); } [Fact] public void ExistingQuantityAndPrecreatedSheetsCompleteWithRealEngine() { var session = Session(); var occupied = session.GetPlate(0); occupied.Quantity = 2; occupied.Parts.Add(new Part(session.Nest.Drawings.Single(d => d.Name == "A"))); var first = new Plate(3, 3) { PartSpacing = 0.25, Quantity = 1 }; var second = new Plate(3, 3) { PartSpacing = 0.25, Quantity = 1 }; session.Plates.Add(first); session.Plates.Add(second); var text = Call(new NestingTools(session), 1, "A,B", "3,1", "Rectangles", noNew: true); Assert.Contains("Whole job complete", text); Assert.Contains("0 new layout(s)", text); Assert.Same(first, session.GetPlate(1)); Assert.Same(second, session.GetPlate(2)); Assert.Equal(3, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(1, session.Nest.Drawings.Single(d => d.Name == "B").Quantity.Nested); Assert.Equal(3, session.AllPlates().Count); var path = Path.Combine(directory, "existing.nest"); Assert.Contains("Saved nest", new InputTools(session).SaveNest(path)); var loaded = new NestReader(path).Read(); Assert.Equal(3, loaded.Plates.Count); Assert.Equal(3, loaded.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(1, loaded.Drawings.Single(d => d.Name == "B").Quantity.Nested); } [Fact] public void RealEngineAddsSheetsWhenOnlyTemplateExists() { var session = Session(); session.GetPlate(0).Size = new Size(3, 3); var text = Call(new NestingTools(session), 0, "A,B", "2,2", "Rectangles"); Assert.Contains("Whole job complete", text); Assert.Equal(4, session.AllPlates().Sum(p => p.Quantity)); Assert.Equal(2, session.AllPlates().Count); Assert.All(session.AllPlates(), p => { Assert.Single(p.Parts); Assert.Equal(2, p.Quantity); }); Assert.Equal(2, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(2, session.Nest.Drawings.Single(d => d.Name == "B").Quantity.Nested); } [Fact] public void InvalidPluginLayoutCannotCreateOrOccupySheets() { var session = Session(); var original = session.GetPlate(0); var engine = "JobOverlap-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "invalid layout", () => new TwoSheetStub(overlap: true)); var text = Call(new NestingTools(session), 0, "A,B", "2,2", engine); Assert.Contains("invalid", text, StringComparison.OrdinalIgnoreCase); Assert.Contains("Nothing committed", text); Assert.Single(session.AllPlates()); Assert.Same(original, session.GetPlate(0)); Assert.Empty(original.Parts); Assert.All(session.Nest.Drawings, d => Assert.Equal(0, d.Quantity.Nested)); } [Fact] public void RestrictedDrawingRejectsPluginRotationWithoutMutationAfterReload() { var session = Session(); var drawing = session.Nest.Drawings.Single(d => d.Name == "A"); drawing.Constraints = new NestConstraints { StepAngle = OpenNest.Math.Angle.TwoPI, StartAngle = 0, EndAngle = 0, }; session.GetPlate(0).Parts.Add(new Part(session.Nest.Drawings.Single(d => d.Name == "B"))); var path = Path.Combine(directory, "rotation.nest"); Assert.True(new NestWriter(session.Nest).Write(path)); session = new NestSession { Nest = new NestReader(path).Read() }; Assert.Equal(OpenNest.Math.Angle.TwoPI, session.Nest.Drawings.Single(d => d.Name == "A").Constraints.StepAngle); session.Plates.Add(new Plate(10, 10) { PartSpacing = 0.25, Quantity = 1 }); var engine = "JobForbiddenRotation-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "rotated proposal", () => new RotatedStub()); var plateTool = new NestingTools(session).AutoNestPlate(1, "A", "1", engine); Assert.Contains("Violation", plateTool); Assert.Contains("rotation", plateTool, StringComparison.OrdinalIgnoreCase); Assert.Empty(session.GetPlate(1).Parts); var text = Call(new NestingTools(session), 1, "A", "1", engine); Assert.True(text.Contains("rotation", StringComparison.OrdinalIgnoreCase), text); Assert.Contains("Nothing committed", text); Assert.Equal(2, session.AllPlates().Count); Assert.Empty(session.GetPlate(1).Parts); Assert.Single(session.GetPlate(0).Parts); Assert.Equal(0, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); } [Fact] public void EquivalentDeserializedCuttingSettingsReuseExistingSheets() { var session = Session(); var first = session.GetPlate(0); first.Size = new Size(3, 3); first.CuttingParameters = new CuttingParameters { MachineName = "Same" }; var second = new Plate(3, 3) { Quantity = 1, PartSpacing = 0.25, CuttingParameters = new CuttingParameters { MachineName = "Same" } }; session.Plates.Add(second); Assert.NotSame(first.CuttingParameters, second.CuttingParameters); var text = Call(new NestingTools(session), 0, "A", "2", "Rectangles", noNew: true); Assert.Contains("Whole job complete", text); Assert.Equal(2, session.AllPlates().Count); Assert.Single(first.Parts); Assert.Equal(2, first.Quantity); Assert.Empty(second.Parts); // redundant empty layout remains untouched, not expanded Assert.Equal(1, second.Quantity); } [Fact] public void DifferentCuttingSettingsAreNotReusedAsStock() { var session = Session(); var first = session.GetPlate(0); first.Size = new Size(3, 3); first.CuttingParameters = new CuttingParameters { MachineName = "First" }; var second = new Plate(3, 3) { Quantity = 1, PartSpacing = 0.25, CuttingParameters = new CuttingParameters { MachineName = "Other" } }; session.Plates.Add(second); var text = Call(new NestingTools(session), 0, "A", "2", "Rectangles", noNew: true); Assert.Contains("incomplete", text, StringComparison.OrdinalIgnoreCase); Assert.Contains("Nothing committed", text); Assert.Empty(first.Parts); Assert.Empty(second.Parts); Assert.Equal(2, session.AllPlates().Count); } [Fact] public void SolverNotSupportedErrorNamesActualCause() { var session = Session(); var engine = "JobUnsupported-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "unsupported solver", () => new UnsupportedStub()); var text = Call(new NestingTools(session), 0, "A", "1", engine); Assert.Contains("unsupported fixture", text); Assert.DoesNotContain("Use autonest_plate", text); Assert.Contains("Nothing committed", text); Assert.Empty(session.GetPlate(0).Parts); } [Fact] public void CancellationAfterPluginIgnoresTokenDoesNotCommit() { var session = Session(); var required = session.AllDrawings().Select(d => d.Quantity.Required).ToArray(); using var cts = new CancellationTokenSource(); var engine = "JobCancel-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "cancels after solving", () => new CancelStub(cts)); Assert.ThrowsAny(() => Call(new NestingTools(session), 0, "A,B", "2,2", engine, token: cts.Token)); Assert.Single(session.AllPlates()); Assert.Empty(session.GetPlate(0).Parts); Assert.All(session.Nest.Drawings, d => Assert.Equal(0, d.Quantity.Nested)); Assert.Equal(required, session.AllDrawings().Select(d => d.Quantity.Required)); } private sealed class CancelStub(CancellationTokenSource source) : INestingEngine { public NestJobResult Solve(NestJob job, IProgress? progress = null, CancellationToken token = default) { var result = new TwoSheetStub().Solve(job, progress, token); source.Cancel(); return result; } } private sealed class RotatedStub : INestingEngine { public NestJobResult Solve(NestJob job, IProgress? progress = null, CancellationToken token = default) { var stock = Assert.Single(job.Plates); return new NestJobResult(NestJobStatus.Complete, NestJobStopReason.Completed, [new NestJobPlateResult(0, stock, [new NestJobPlacement(job.Parts[0].Id, 0, 4, 4, System.Math.PI / 2)])], [], []); } } private sealed class UnsupportedStub : INestingEngine { public NestJobResult Solve(NestJob job, IProgress? progress = null, CancellationToken token = default) => throw new NotSupportedException("unsupported fixture"); } [Theory] [InlineData(false)] [InlineData(true)] public void RealRepeatedJobPreservesQuantitiesAndExistingOnlyPhysicalCap(bool noNew) { var session = Session(); var template = session.GetPlate(0); template.Size = new Size(4.5, 4.5); var drawing = session.Nest.Drawings.Single(d => d.Name == "A"); drawing.Constraints = new NestConstraints { StepAngle = OpenNest.Math.Angle.TwoPI, StartAngle = 0, EndAngle = 0 }; if (noNew) { session.Plates.Add(new Plate(4.5, 4.5) { PartSpacing = 0.25 }); session.Plates.Add(new Plate(4.5, 4.5) { PartSpacing = 0.25 }); } var output = new NestingTools(session).AutoNestJob(0, "A", "9", "Rectangles", no_new_plates: noNew, sheets: noNew ? null : [new SheetStockInput { Width = 4.5, Length = 4.5, Quantity = 4, Cost = 7 }]); Assert.Contains("3 sheet(s) placed in 2 layout(s)", output); Assert.Equal(new[] { 2, 1 }, session.AllPlates().Where(p => p.Parts.Count > 0).Select(p => p.Quantity)); Assert.Equal(9, drawing.Quantity.Nested); Assert.Equal(9, drawing.Quantity.Required); if (noNew) { Assert.Contains("0 new layout(s)", output); Assert.Equal(3, session.AllPlates().Count); Assert.Empty(session.GetPlate(2).Parts); } else { Assert.Contains("gross total=21", output); Assert.Contains("stock-0 (4.5x4.5): used=3, remaining=1, reused=1, created=1 (layout counts)", output); Assert.Contains("plate 0 -> stock-0", output); Assert.Contains("plate 1 -> stock-0", output); } var path = Path.Combine(directory, "repeated.nest"); Assert.Contains("Saved nest", new InputTools(session).SaveNest(path)); var loaded = new NestReader(path).Read(); Assert.Equal(new[] { 2, 1 }, loaded.Plates.Select(p => p.Quantity)); Assert.Equal(9, loaded.Drawings.Single(d => d.Name == "A").Quantity.Nested); } [Theory] [InlineData(false)] [InlineData(true)] public void RepeatedLayoutCannotHideInsufficientPhysicalStock(bool noNew) { var session = Session(); session.GetPlate(0).Size = new Size(3, 3); if (noNew) session.Plates.Add(new Plate(3, 3) { PartSpacing = 0.25 }); var output = new NestingTools(session).AutoNestJob(0, "A", "3", "Rectangles", no_new_plates: noNew, sheets: noNew ? null : [new SheetStockInput { Width = 3, Length = 3, Quantity = 2 }]); Assert.Contains("incomplete", output, StringComparison.OrdinalIgnoreCase); Assert.Contains("Nothing committed", output); Assert.All(session.AllPlates(), p => Assert.Empty(p.Parts)); Assert.Equal(0, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); } [Fact] public void MixedStockGroupedMappingReportsWeightedUsageAndCostWithoutFlattening() { var session = Session(); var template = session.GetPlate(0); template.Size = new Size(3, 3); var engine = "GroupedStock-" + Guid.NewGuid(); NestingEngineRegistry.Register(engine, "expanded exact layouts", () => new InspectStub(job => { var builder = new NestJobResultBuilder(job); builder.AddSheet(job.Plates[1], [(job.Parts[1].Id, 1d, 1d, 0d)]); builder.AddSheet(job.Plates[0], [(job.Parts[0].Id, 0.5, 0.5, 0d)]); builder.AddSheet(job.Plates[1], [(job.Parts[1].Id, 1d, 1d, 0d)]); builder.AddSheet(job.Plates[0], [(job.Parts[0].Id, 0.5, 0.5, 0d)]); return builder.Build(NestJobStopReason.Completed); })); var text = new NestingTools(session).AutoNestJob(0, "A,B", "2,2", engine, sheets: [new SheetStockInput { Width = 3, Length = 3, Quantity = 3, Cost = 5 }, new SheetStockInput { Width = 6, Length = 6, Quantity = 2, Cost = 7 }]); Assert.Contains("4 sheet(s) placed in 2 layout(s)", text); Assert.Contains("gross total=24", text); Assert.Contains("stock-0 (3x3): used=2, remaining=1, reused=1, created=0 (layout counts)", text); Assert.Contains("stock-1 (6x6): used=2, remaining=0, reused=0, created=1 (layout counts)", text); Assert.Contains("plate 0 -> stock-0", text); Assert.Contains("plate 1 -> stock-1", text); Assert.Same(template, session.GetPlate(0)); Assert.Equal(2, session.AllPlates().Count); Assert.All(session.AllPlates(), p => { Assert.Equal(2, p.Quantity); Assert.Single(p.Parts); }); Assert.All(session.AllDrawings(), d => Assert.Equal(2, d.Quantity.Nested)); } [Theory] [InlineData(false)] [InlineData(true)] public void ExistingOnlyGroupedCopiesCannotOfferConsumedEmptyPlaceholdersAsStockAgain(bool noNew) { var session = Session(); session.GetPlate(0).Size = new Size(3, 3); var consumed = new Plate(3, 3) { PartSpacing = 0.25 }; var spare = new Plate(3, 3) { PartSpacing = 0.25 }; session.Plates.Add(consumed); session.Plates.Add(spare); var tools = new NestingTools(session); var first = tools.AutoNestJob(0, "A", "2", "Rectangles", no_new_plates: noNew, sheets: noNew ? null : [new SheetStockInput { Width = 3, Length = 3, Quantity = 2 }]); Assert.Contains("2 sheet(s) placed in 1 layout(s)", first); Assert.Equal(2, session.GetPlate(0).Quantity); Assert.Empty(consumed.Parts); Assert.Empty(spare.Parts); // Two physical sheets were consumed, so only one of the two empty entries is free. var output = Call(new NestingTools(session), 2, "A,B", "2,2", "Rectangles", noNew: true); Assert.Contains("Nothing committed", output); Assert.Equal(2, session.Nest.Drawings.Single(d => d.Name == "A").Quantity.Nested); Assert.Equal(0, session.Nest.Drawings.Single(d => d.Name == "B").Quantity.Nested); Assert.Equal(3, session.AllPlates().Count); Assert.Empty(consumed.Parts); Assert.Empty(spare.Parts); // Explicitly selecting the consumed placeholder must not resurrect it either. Assert.Contains("Nothing committed", Call(new NestingTools(session), 1, "B", "1", "Rectangles", noNew: true)); Assert.Contains("consumed", tools.FillPlate(1, "B", 1)); Assert.Contains("consumed", tools.FillArea(1, "B", 0, 0, 3, 3, 1)); Assert.Contains("consumed", tools.FillRemnants(1, "B", 1)); Assert.Contains("consumed", tools.PackPlate(1, "B", "1")); Assert.Contains("consumed", tools.AutoNestPlate(1, "B", "1", allow_invalid: true)); Assert.Empty(consumed.Parts); // Rejection must not consume the genuinely unused last physical sheet. Assert.Contains("1 sheet(s) placed in 1 layout(s)", Call(new NestingTools(session), 2, "A,B", "2,1", "Rectangles", noNew: true)); Assert.Single(spare.Parts); Assert.Equal(1, spare.Quantity); Assert.Equal(1, session.Nest.Drawings.Single(d => d.Name == "B").Quantity.Nested); } private sealed class TwoSheetStub(bool overlap = false) : INestingEngine { public NestJobResult Solve(NestJob job, IProgress? progress = null, CancellationToken token = default) { var stock = Assert.Single(job.Plates); var sheets = new List(); for (var i = 0; i < System.Math.Min(2, stock.Quantity ?? 2); i++) sheets.Add(new NestJobPlateResult(i, stock, [new NestJobPlacement(job.Parts[0].Id, i, 1, 1, 0), new NestJobPlacement(job.Parts[1].Id, i, overlap ? 1 : 5, 1, 0)])); return new NestJobResult(sheets.Count == 2 ? NestJobStatus.Complete : NestJobStatus.Incomplete, sheets.Count == 2 ? NestJobStopReason.Completed : NestJobStopReason.StockExhausted, sheets, [], []); } } }