More Path extensions tests

Author: JimBobSquarePants

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

@@ -10,12 +10,15 @@ public class PathExtentionTests
 {
     private RectangleF bounds;
     private readonly Mock<IPath> mockPath;
+    private readonly Mock<IPathCollection> mockPathCollection;
 
     public PathExtentionTests()
     {
         this.bounds = new RectangleF(10, 10, 20, 20);
         this.mockPath = new Mock<IPath>();
         this.mockPath.Setup(x => x.Bounds).Returns(() => this.bounds);
+        this.mockPathCollection = new Mock<IPathCollection>();
+        this.mockPathCollection.Setup(x => x.Bounds).Returns(() => this.bounds);
     }
 
     [Fact]
@@ -96,4 +99,105 @@ public void TranslateXY()
 
         this.mockPath.Verify(p => p.Transform(It.IsAny<Matrix4x4>()), Times.Once);
     }
+
+    [Fact]
+    public void TranslatePoint()
+    {
+        PointF point = new(98, 120);
+        Matrix4x4 targetMatrix = Matrix4x4.CreateTranslation(point.X, point.Y, 0);
+
+        this.VerifyPathTransform(path => path.Translate(point), targetMatrix);
+    }
+
+    [Fact]
+    public void ScaleXY()
+    {
+        Matrix4x4 targetMatrix = Matrix4x4.CreateScale(2, 3, 1, new Vector3(RectangleF.Center(this.bounds), 0));
+
+        this.VerifyPathTransform(path => path.Scale(2, 3), targetMatrix);
+    }
+
+    [Fact]
+    public void ScaleUniform()
+    {
+        Matrix4x4 targetMatrix = Matrix4x4.CreateScale(4, 4, 1, new Vector3(RectangleF.Center(this.bounds), 0));
+
+        this.VerifyPathTransform(path => path.Scale(4), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionRotateInRadians()
+    {
+        const float Angle = (float)Math.PI;
+        Matrix4x4 targetMatrix = new(Matrix3x2.CreateRotation(Angle, RectangleF.Center(this.bounds)));
+
+        this.VerifyPathCollectionTransform(path => path.Rotate(Angle), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionRotateInDegrees()
+    {
+        const float Angle = 90;
+        const float Radians = (float)(Math.PI * Angle / 180.0);
+        Matrix4x4 targetMatrix = new(Matrix3x2.CreateRotation(Radians, RectangleF.Center(this.bounds)));
+
+        this.VerifyPathCollectionTransform(path => path.RotateDegree(Angle), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionTranslatePoint()
+    {
+        PointF point = new(98, 120);
+        Matrix4x4 targetMatrix = Matrix4x4.CreateTranslation(point.X, point.Y, 0);
+
+        this.VerifyPathCollectionTransform(path => path.Translate(point), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionTranslateXY()
+    {
+        const float X = 76;
+        const float Y = 7;
+        Matrix4x4 targetMatrix = Matrix4x4.CreateTranslation(X, Y, 0);
+
+        this.VerifyPathCollectionTransform(path => path.Translate(X, Y), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionScaleXY()
+    {
+        Matrix4x4 targetMatrix = Matrix4x4.CreateScale(2, 3, 1, new Vector3(RectangleF.Center(this.bounds), 0));
+
+        this.VerifyPathCollectionTransform(path => path.Scale(2, 3), targetMatrix);
+    }
+
+    [Fact]
+    public void CollectionScaleUniform()
+    {
+        Matrix4x4 targetMatrix = Matrix4x4.CreateScale(4, 4, 1, new Vector3(RectangleF.Center(this.bounds), 0));
+
+        this.VerifyPathCollectionTransform(path => path.Scale(4), targetMatrix);
+    }
+
+    private void VerifyPathTransform(Action<IPath> transform, Matrix4x4 targetMatrix)
+    {
+        this.mockPath.Setup(x => x.Transform(It.IsAny<Matrix4x4>()))
+            .Callback<Matrix4x4>(m => Assert.Equal(targetMatrix, m))
+            .Returns(this.mockPath.Object);
+
+        transform(this.mockPath.Object);
+
+        this.mockPath.Verify(x => x.Transform(It.IsAny<Matrix4x4>()), Times.Once);
+    }
+
+    private void VerifyPathCollectionTransform(Action<IPathCollection> transform, Matrix4x4 targetMatrix)
+    {
+        this.mockPathCollection.Setup(x => x.Transform(It.IsAny<Matrix4x4>()))
+            .Callback<Matrix4x4>(m => Assert.Equal(targetMatrix, m))
+            .Returns(this.mockPathCollection.Object);
+
+        transform(this.mockPathCollection.Object);
+
+        this.mockPathCollection.Verify(x => x.Transform(It.IsAny<Matrix4x4>()), Times.Once);
+    }
 }

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

@@ -85,4 +85,56 @@ public void EmptyPath_ToLinearGeometry_ReturnsEmptyGeometry()
 
         Assert.False(segments.MoveNext());
     }
+
+    [Fact]
+    public void PathCollection_EnumerableConstructor_PreservesPaths()
+    {
+        IPath first = new RectangularPolygon(1, 2, 3, 4);
+        IPath second = new RectangularPolygon(10, 20, 5, 6);
+
+        PathCollection collection = new(new[] { first, second }.AsEnumerable());
+
+        IPath[] paths = collection.ToArray();
+        Assert.Equal(2, paths.Length);
+        Assert.Same(first, paths[0]);
+        Assert.Same(second, paths[1]);
+    }
+
+    [Fact]
+    public void PathCollection_Bounds_AggregatesPathBounds()
+    {
+        PathCollection collection = new(
+            new RectangularPolygon(1, 2, 3, 4),
+            new RectangularPolygon(10, 20, 5, 6));
+
+        Assert.Equal(new RectangleF(1, 2, 14, 24), collection.Bounds);
+    }
+
+    [Fact]
+    public void PathCollection_Bounds_ReturnsEmptyForEmptyCollection()
+    {
+        PathCollection collection = new();
+
+        Assert.Equal(RectangleF.Empty, collection.Bounds);
+    }
+
+    [Fact]
+    public void PathCollection_Transform_TransformsEachPath()
+    {
+        PathCollection collection = new(
+            new RectangularPolygon(1, 2, 3, 4),
+            new RectangularPolygon(10, 20, 5, 6));
+        Matrix4x4 matrix = Matrix4x4.CreateTranslation(7, 11, 0);
+
+        IPathCollection transformed = collection.Transform(matrix);
+
+        Assert.NotSame(collection, transformed);
+        Assert.Equal(new RectangleF(8, 13, 14, 24), transformed.Bounds);
+        Assert.Equal(new RectangleF(1, 2, 14, 24), collection.Bounds);
+
+        RectangleF[] transformedBounds = transformed.Select(x => x.Bounds).ToArray();
+        Assert.Equal(2, transformedBounds.Length);
+        Assert.Equal(new RectangleF(8, 13, 3, 4), transformedBounds[0]);
+        Assert.Equal(new RectangleF(17, 31, 5, 6), transformedBounds[1]);
+    }
 }