Cover the small zero-coverage types and exclude submodule sources

The shared-infrastructure guard sources are covered by the submodule's own
tests and are excluded from this repository's metric.

New tests cover the Brushes pattern factories in both overload forms, the
LinearGeometry polyline surface including segment enumeration, lengths,
shoelace areas, winding containment, distance queries and sub-path
extraction, path normalization including the positive-winding lobe
selection for self-intersecting contours, the native-to-public error type
mapping, the window option defaults, the shader diagnostic and compilation
exception surface, and the native type name attribute.

Author: JimBobSquarePants

tests/ImageSharp.Drawing.Tests/Processing/Backends/NativeTypeNameAttributeTests.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing.Backends.Native;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Processing.Backends;
+
+public class NativeTypeNameAttributeTests
+{
+    [Fact]
+    public void Constructor_StoresNativeName()
+        => Assert.Equal("WGPUBool", new NativeTypeNameAttribute("WGPUBool").Name);
+}

tests/ImageSharp.Drawing.Tests/Processing/Backends/WebGPUErrorTypeMapperTests.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing.Backends;
+using SixLabors.ImageSharp.Drawing.Processing.Backends.Native;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Processing.Backends;
+
+public class WebGPUErrorTypeMapperTests
+{
+    [Fact]
+    public void ToPublic_MapsEveryNativeClassification()
+    {
+        Assert.Equal(WebGPUErrorType.NoError, WebGPUErrorTypeMapper.ToPublic(WGPUErrorType.NoError));
+        Assert.Equal(WebGPUErrorType.Validation, WebGPUErrorTypeMapper.ToPublic(WGPUErrorType.Validation));
+        Assert.Equal(WebGPUErrorType.OutOfMemory, WebGPUErrorTypeMapper.ToPublic(WGPUErrorType.OutOfMemory));
+        Assert.Equal(WebGPUErrorType.Internal, WebGPUErrorTypeMapper.ToPublic(WGPUErrorType.Internal));
+        Assert.Equal(WebGPUErrorType.Unknown, WebGPUErrorTypeMapper.ToPublic(WGPUErrorType.Unknown));
+        Assert.Equal(WebGPUErrorType.Unknown, WebGPUErrorTypeMapper.ToPublic((WGPUErrorType)int.MaxValue));
+    }
+}

tests/ImageSharp.Drawing.Tests/Processing/Backends/WebGPUShaderDiagnosticTests.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Processing.Backends;
+
+public class WebGPUShaderDiagnosticTests
+{
+    [Fact]
+    public void Constructor_StoresAllValues()
+    {
+        WebGPUShaderDiagnostic diagnostic = new(WebGPUShaderDiagnosticSeverity.Error, "bad shader", 4, 7);
+
+        Assert.Equal(WebGPUShaderDiagnosticSeverity.Error, diagnostic.Severity);
+        Assert.Equal("bad shader", diagnostic.Message);
+        Assert.Equal(4, diagnostic.Line);
+        Assert.Equal(7, diagnostic.Column);
+    }
+
+    [Fact]
+    public void CompilationException_ExposesMessageAndDiagnostics()
+    {
+        WebGPUShaderDiagnostic[] diagnostics =
+        [
+            new(WebGPUShaderDiagnosticSeverity.Warning, "first", 1, 2),
+            new(WebGPUShaderDiagnosticSeverity.Error, "second", 3, 4),
+        ];
+
+        WebGPUShaderCompilationException exception = new("compilation failed", diagnostics);
+
+        Assert.Equal("compilation failed", exception.Message);
+        Assert.Equal(2, exception.Diagnostics.Count);
+        Assert.Equal("second", exception.Diagnostics[1].Message);
+    }
+}

tests/ImageSharp.Drawing.Tests/Processing/Backends/WebGPUWindowOptionsTests.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing.Backends;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Processing.Backends;
+
+public class WebGPUWindowOptionsTests
+{
+    [Fact]
+    public void Defaults_MatchDocumentedInitialConfiguration()
+    {
+        WebGPUWindowOptions options = new();
+
+        Assert.Equal("ImageSharp.Drawing WebGPU", options.Title);
+        Assert.Equal(new Size(1280, 720), options.Size);
+        Assert.Equal(new Point(50, 50), options.Position);
+        Assert.True(options.IsVisible);
+        Assert.Equal(0, options.FramesPerSecond);
+        Assert.Equal(0, options.UpdatesPerSecond);
+        Assert.False(options.IsEventDriven);
+        Assert.Equal(WebGPUWindowState.Normal, options.WindowState);
+        Assert.Equal(WebGPUWindowBorder.Resizable, options.WindowBorder);
+        Assert.False(options.IsTopMost);
+        Assert.Equal(WebGPUPresentMode.Fifo, options.PresentMode);
+        Assert.Equal(WebGPUTextureFormat.Rgba8Unorm, options.Format);
+    }
+}

tests/ImageSharp.Drawing.Tests/Processing/BrushesTests.cs

@@ -0,0 +1,69 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using SixLabors.ImageSharp.Drawing.Processing;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Processing;
+
+public class BrushesTests
+{
+    public static TheoryData<string> PatternFactoryNames { get; } = new()
+    {
+        nameof(Brushes.Horizontal),
+        nameof(Brushes.Min),
+        nameof(Brushes.Vertical),
+        nameof(Brushes.ForwardDiagonal),
+        nameof(Brushes.BackwardDiagonal),
+        nameof(Brushes.Cross),
+        nameof(Brushes.DiagonalCross),
+    };
+
+    [Fact]
+    public void Solid_CreatesBrushWithColor()
+    {
+        SolidBrush brush = Brushes.Solid(Color.Red);
+
+        Assert.Equal(Color.Red, brush.Color);
+    }
+
+    [Theory]
+    [MemberData(nameof(PatternFactoryNames))]
+    public void PatternFactories_SingleColor_UseTransparentBackground(string name)
+    {
+        PatternBrush brush = InvokePatternFactory(name, Color.Red, null);
+
+        Assert.Contains(Color.Red, brush.Pattern.Data);
+        Assert.Contains(Color.Transparent, brush.Pattern.Data);
+    }
+
+    [Theory]
+    [MemberData(nameof(PatternFactoryNames))]
+    public void PatternFactories_TwoColors_UseBothColors(string name)
+    {
+        PatternBrush brush = InvokePatternFactory(name, Color.Red, Color.Blue);
+
+        Assert.Contains(Color.Red, brush.Pattern.Data);
+        Assert.Contains(Color.Blue, brush.Pattern.Data);
+        Assert.DoesNotContain(Color.Transparent, brush.Pattern.Data);
+    }
+
+    private static PatternBrush InvokePatternFactory(string name, Color foreColor, Color? backColor)
+        => (name, backColor) switch
+        {
+            (nameof(Brushes.Horizontal), null) => Brushes.Horizontal(foreColor),
+            (nameof(Brushes.Horizontal), _) => Brushes.Horizontal(foreColor, backColor.Value),
+            (nameof(Brushes.Min), null) => Brushes.Min(foreColor),
+            (nameof(Brushes.Min), _) => Brushes.Min(foreColor, backColor.Value),
+            (nameof(Brushes.Vertical), null) => Brushes.Vertical(foreColor),
+            (nameof(Brushes.Vertical), _) => Brushes.Vertical(foreColor, backColor.Value),
+            (nameof(Brushes.ForwardDiagonal), null) => Brushes.ForwardDiagonal(foreColor),
+            (nameof(Brushes.ForwardDiagonal), _) => Brushes.ForwardDiagonal(foreColor, backColor.Value),
+            (nameof(Brushes.BackwardDiagonal), null) => Brushes.BackwardDiagonal(foreColor),
+            (nameof(Brushes.BackwardDiagonal), _) => Brushes.BackwardDiagonal(foreColor, backColor.Value),
+            (nameof(Brushes.Cross), null) => Brushes.Cross(foreColor),
+            (nameof(Brushes.Cross), _) => Brushes.Cross(foreColor, backColor.Value),
+            (nameof(Brushes.DiagonalCross), null) => Brushes.DiagonalCross(foreColor),
+            (nameof(Brushes.DiagonalCross), _) => Brushes.DiagonalCross(foreColor, backColor.Value),
+            _ => throw new ArgumentOutOfRangeException(nameof(name)),
+        };
+}

tests/ImageSharp.Drawing.Tests/Shapes/LinearGeometryTests.cs

@@ -0,0 +1,183 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Shapes;
+
+public class LinearGeometryTests
+{
+    private static LinearGeometry CreateLPolyline()
+        => LinearGeometry.CreateOpenPolyline(
+        [
+            new PointF(0, 0),
+            new PointF(10, 0),
+            new PointF(10, 10),
+        ]);
+
+    private static LinearGeometry CreateClosedSquare()
+    {
+        PointF[] points =
+        [
+            new PointF(0, 0),
+            new PointF(10, 0),
+            new PointF(10, 10),
+            new PointF(0, 10),
+        ];
+        RectangleF bounds = RectangleF.FromLTRB(0, 0, 10, 10);
+
+        return new LinearGeometry(
+            new LinearGeometryInfo
+            {
+                Bounds = bounds,
+                ContourCount = 1,
+                PointCount = points.Length,
+                SegmentCount = points.Length,
+            },
+            [new LinearContour
+            {
+                PointStart = 0,
+                PointCount = points.Length,
+                Bounds = bounds,
+                SegmentStart = 0,
+                SegmentCount = points.Length,
+                IsClosed = true,
+            }
+            ],
+            points);
+    }
+
+    [Fact]
+    public void CreateOpenPolyline_PopulatesInfoAndContours()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.Equal(1, geometry.Info.ContourCount);
+        Assert.Equal(3, geometry.Info.PointCount);
+        Assert.Equal(2, geometry.Info.SegmentCount);
+        Assert.Equal(RectangleF.FromLTRB(0, 0, 10, 10), geometry.Info.Bounds);
+
+        LinearContour contour = Assert.Single(geometry.Contours);
+        Assert.False(contour.IsClosed);
+        Assert.Equal(3, geometry.Points.Count);
+    }
+
+    [Fact]
+    public void CreateOpenPolyline_AppliesScale()
+    {
+        LinearGeometry geometry = LinearGeometry.CreateOpenPolyline(
+            [new PointF(1, 2), new PointF(3, 4)],
+            new Vector2(2, 10));
+
+        Assert.Equal(new PointF(2, 20), geometry.Points[0]);
+        Assert.Equal(new PointF(6, 40), geometry.Points[1]);
+    }
+
+    [Fact]
+    public void CreateOpenPolyline_FewerThanTwoPoints_Throws()
+        => Assert.Throws<ArgumentOutOfRangeException>(() => LinearGeometry.CreateOpenPolyline([new PointF(0, 0)]));
+
+    [Fact]
+    public void GetSegments_YieldsEachSegmentInOrder()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+        List<(PointF Start, PointF End)> segments = [];
+
+        SegmentEnumerator enumerator = geometry.GetSegments();
+        while (enumerator.MoveNext())
+        {
+            segments.Add((enumerator.Current.Start, enumerator.Current.End));
+        }
+
+        Assert.Equal(
+        [
+            (new PointF(0, 0), new PointF(10, 0)),
+            (new PointF(10, 0), new PointF(10, 10)),
+        ],
+            segments);
+    }
+
+    [Fact]
+    public void ComputeLength_SumsSegmentLengths()
+        => Assert.Equal(20F, CreateLPolyline().ComputeLength());
+
+    [Fact]
+    public void ComputeArea_OpenRunWithThreePoints_UsesShoelaceOfPointRun()
+        => Assert.Equal(50F, CreateLPolyline().ComputeArea());
+
+    [Fact]
+    public void ComputeArea_ClosedSquare_ReturnsEnclosedArea()
+        => Assert.Equal(100F, CreateClosedSquare().ComputeArea());
+
+    [Fact]
+    public void Contains_OpenContour_NeverContains()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.False(geometry.Contains(new PointF(9, 1), IntersectionRule.NonZero));
+        Assert.False(geometry.Contains(new PointF(9, 1), IntersectionRule.EvenOdd));
+    }
+
+    [Theory]
+    [InlineData(5, 5, true)]
+    [InlineData(0, 0, true)]
+    [InlineData(15, 5, false)]
+    [InlineData(-1, 5, false)]
+    public void Contains_ClosedContour_UsesWinding(float x, float y, bool expected)
+    {
+        LinearGeometry geometry = CreateClosedSquare();
+
+        Assert.Equal(expected, geometry.Contains(new PointF(x, y), IntersectionRule.NonZero));
+        Assert.Equal(expected, geometry.Contains(new PointF(x, y), IntersectionRule.EvenOdd));
+    }
+
+    [Theory]
+    [InlineData(0, 0, 0)]
+    [InlineData(5, 5, 0)]
+    [InlineData(15, 10, 5)]
+    [InlineData(20, 10, 10)]
+    public void TryGetPathPointAtDistance_WithinLength_ReturnsPointOnPolyline(float distance, float x, float y)
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.True(geometry.TryGetPathPointAtDistance(distance, out PathPoint pathPoint));
+        Assert.Equal(new PointF(x, y), pathPoint.Point);
+    }
+
+    [Fact]
+    public void TryGetPathPointAtDistance_BeyondOpenPolyline_ReturnsFalse()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.False(geometry.TryGetPathPointAtDistance(25, out _));
+        Assert.False(geometry.TryGetPathPointAtDistance(-1, out _));
+        Assert.False(geometry.TryGetPathPointAtDistance(float.NaN, out _));
+    }
+
+    [Fact]
+    public void TryGetPathPointAtDistanceUnbounded_ExtrapolatesAlongEndTangent()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.True(geometry.TryGetPathPointAtDistanceUnbounded(25, out PathPoint pathPoint));
+        Assert.Equal(new PointF(10, 15), pathPoint.Point);
+    }
+
+    [Fact]
+    public void TryGetPathPointAtDistanceUnbounded_NegativeDistance_ExtrapolatesBeforeStart()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.True(geometry.TryGetPathPointAtDistanceUnbounded(-5, out PathPoint pathPoint));
+        Assert.Equal(new PointF(-5, 0), pathPoint.Point);
+    }
+
+    [Fact]
+    public void TryGetSegment_ReturnsSubPathBetweenDistances()
+    {
+        LinearGeometry geometry = CreateLPolyline();
+
+        Assert.True(geometry.TryGetSegment(5, 15, false, out IPath segment));
+        Assert.Equal(RectangleF.FromLTRB(5, 0, 10, 5), segment.Bounds);
+    }
+}