Add tests for Scale element

Source/QuestPDF.LayoutTests/ScaleTests.cs

@@ -0,0 +1,285 @@
+using QuestPDF.Helpers;
+
+namespace QuestPDF.LayoutTests;
+
+public class ScaleTests
+{
+    private void DrawTestSubject(IContainer container)
+    {
+        container
+            .Inlined(inlined =>
+            {
+                inlined.Item().Mock("a").SolidBlock(100, 100);
+                inlined.Item().Mock("b").SolidBlock(100, 100);
+                inlined.Item().Mock("c").SolidBlock(100, 100);
+                inlined.Item().Mock("d").SolidBlock(100, 100);
+                inlined.Item().Mock("e").SolidBlock(100, 100);
+                inlined.Item().Mock("f").SolidBlock(100, 100);
+            });
+    }
+    
+    [Test]
+    public void DefaultScale()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(800, 500)
+            .ForContent(content =>
+            {
+                content.Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(600, 100)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(100, 0).Size(100, 100);
+                        page.Mock("c").Position(200, 0).Size(100, 100);
+                        page.Mock("d").Position(300, 0).Size(100, 100);
+                        page.Mock("e").Position(400, 0).Size(100, 100);
+                        page.Mock("f").Position(500, 0).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PositiveScale05()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(800, 500)
+            .ForContent(content =>
+            {
+                content.Scale(0.5f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(300, 50)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(50, 0).Size(100, 100);
+                        page.Mock("c").Position(100, 0).Size(100, 100);
+                        page.Mock("d").Position(150, 0).Size(100, 100);
+                        page.Mock("e").Position(200, 0).Size(100, 100);
+                        page.Mock("f").Position(250, 0).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PositiveScale15()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(800, 500)
+            .ForContent(content =>
+            {
+                content.Scale(1.5f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(750, 300)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(150, 0).Size(100, 100);
+                        page.Mock("c").Position(300, 0).Size(100, 100);
+                        page.Mock("d").Position(450, 0).Size(100, 100);
+                        page.Mock("e").Position(600, 0).Size(100, 100);
+                        page.Mock("f").Position(0, 150).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PositiveScale25()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(800, 500)
+            .ForContent(content =>
+            {
+                content.Scale(2.5f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(750, 500)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(250, 0).Size(100, 100);
+                        page.Mock("c").Position(500, 0).Size(100, 100);
+                        page.Mock("d").Position(0, 250).Size(100, 100);
+                        page.Mock("e").Position(250, 250).Size(100, 100);
+                        page.Mock("f").Position(500, 250).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PositiveScaleTwoPages()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(800, 250)
+            .ForContent(content =>
+            {
+                content.Scale(2).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(800, 200)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(200, 0).Size(100, 100);
+                        page.Mock("c").Position(400, 0).Size(100, 100);
+                        page.Mock("d").Position(600, 0).Size(100, 100);
+                    });
+                
+                document
+                    .Page()
+                    .RequiredAreaSize(400, 200)
+                    .Content(page =>
+                    {
+                        page.Mock("e").Position(0, 0).Size(100, 100);
+                        page.Mock("f").Position(200, 0).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void ScaleVertical()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(450, 800)
+            .ForContent(content =>
+            {
+                content.ScaleVertical(2f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(400, 400)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(100, 0).Size(100, 100);
+                        page.Mock("c").Position(200, 0).Size(100, 100);
+                        page.Mock("d").Position(300, 0).Size(100, 100);
+                        page.Mock("e").Position(0, 200).Size(100, 100);
+                        page.Mock("f").Position(100, 200).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void ScaleVerticalNegative()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(400, 500)
+            .ForContent(content =>
+            {
+                content.ScaleVertical(-1.5f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(400, 300)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 500).Size(100, 100);
+                        page.Mock("b").Position(100, 500).Size(100, 100);
+                        page.Mock("c").Position(200, 500).Size(100, 100);
+                        page.Mock("d").Position(300, 500).Size(100, 100);
+                        page.Mock("e").Position(0, 350).Size(100, 100);
+                        page.Mock("f").Position(100, 350).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void ScaleHorizontal()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(450, 800)
+            .ForContent(content =>
+            {
+                content.ScaleHorizontal(2f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(400, 300)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(100, 100);
+                        page.Mock("b").Position(200, 0).Size(100, 100);
+                        page.Mock("c").Position(0, 100).Size(100, 100);
+                        page.Mock("d").Position(200, 100).Size(100, 100);
+                        page.Mock("e").Position(0, 200).Size(100, 100);
+                        page.Mock("f").Position(200, 200).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void ScaleHorizontalNegative()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(700, 400)
+            .ForContent(content =>
+            {
+                content.ScaleHorizontal(-1.5f).Element(DrawTestSubject);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(600, 200)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(700, 0).Size(100, 100);
+                        page.Mock("b").Position(550, 0).Size(100, 100);
+                        page.Mock("c").Position(400, 0).Size(100, 100);
+                        page.Mock("d").Position(250, 0).Size(100, 100);
+                        page.Mock("e").Position(700, 100).Size(100, 100);
+                        page.Mock("f").Position(550, 100).Size(100, 100);
+                    });
+            });
+    }
+    
+    [Test]
+    public void WrapHorizontal()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 100)
+            .ForContent(content =>
+            {
+                content.Scale(3).Width(50).Height(10);
+            })
+            .ExpectLayoutException("The available horizontal space is less than the minimum width.");
+    }
+    
+    [Test]
+    public void WrapVertical()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 100)
+            .ForContent(content =>
+            {
+                content.Scale(3).Width(10).Height(50);
+            })
+            .ExpectLayoutException("The available vertical space is less than the minimum height.");
+    }
+}

Source/QuestPDF.UnitTests/ScaleTests.cs

@@ -1,6 +1,8 @@
-using NUnit.Framework;
+using System;
+using NUnit.Framework;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
+using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 
@@ -9,144 +11,137 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class ScaleTests
     {
-        #region measure
+        [TestCase(2, 2, ExpectedResult = "A=2")]
+        [TestCase(-3, -3, ExpectedResult = "A=-3")]
+        [TestCase(4, 1, ExpectedResult = "H=4")]
+        [TestCase(1, -2, ExpectedResult = "V=-2")]
+        [TestCase(4, 5, ExpectedResult = "H=4   V=5")]
+        [TestCase(1.2345f, -2.3456f, ExpectedResult = "H=1.2   V=-2.3")]
+        public string CompanionHint(float horizontal, float vertical)
+        {
+            var container = EmptyContainer.Create();
+
+            container.ScaleHorizontal(horizontal).ScaleVertical(vertical);
+            
+            var translationElement = container.Child as Scale;
+            return translationElement?.GetCompanionHint();
+        }     
+        
+        #region Cumulative Property
         
         [Test]
-        public void Measure_Wrap()
+        public void HorizontalScaleIsCumulative()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 3,
-                    ScaleY = 2
-                })
-                .MeasureElement(new Size(900, 800))
-                .ExpectChildMeasure(new Size(300, 400), SpacePlan.Wrap("Mock"))
-                .CheckMeasureResult(SpacePlan.Wrap("Forwarded from child"));
+            var container = EmptyContainer.Create();
+        
+            container.ScaleHorizontal(3).ScaleHorizontal(0.5f).ScaleHorizontal(-4);
+        
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(-6));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(1));
         }
         
         [Test]
-        public void Measure_PartialRender()
+        public void VerticalScaleIsCumulative()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 3,
-                    ScaleY = 2
-                })
-                .MeasureElement(new Size(900, 800))
-                .ExpectChildMeasure(new Size(300, 400), SpacePlan.PartialRender(200, 350))
-                .CheckMeasureResult(SpacePlan.PartialRender(600, 700));
+            var container = EmptyContainer.Create();
+        
+            container.ScaleVertical(2).ScaleVertical(-0.25f).ScaleVertical(-3f);
+        
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(1));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(1.5f));
         }
         
         [Test]
-        public void Measure_FullRender()
+        public void ScaleIsCumulative()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 3,
-                    ScaleY = 2
-                })
-                .MeasureElement(new Size(900, 800))
-                .ExpectChildMeasure(new Size(300, 400), SpacePlan.FullRender(250, 300))
-                .CheckMeasureResult(SpacePlan.FullRender(750, 600));
+            var container = EmptyContainer.Create();
+        
+            container.ScaleHorizontal(-5f).ScaleVertical(3).Scale(-0.25f);
+        
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(1.25f));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(-0.75f));
         }
         
+        #endregion
+        
+        #region Flip
+        
         [Test]
-        public void Measure_NegativeScaleX()
+        public void FlipHorizontalAppliesCorrectScale()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = -2,
-                    ScaleY = 1
-                })
-                .MeasureElement(new Size(800, 600))
-                .ExpectChildMeasure(new Size(400, 600), SpacePlan.FullRender(300, 500))
-                .CheckMeasureResult(SpacePlan.FullRender(600, 500));
+            var container = EmptyContainer.Create();
+        
+            container.FlipHorizontal();
+        
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(-1));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(1));
         }
         
         [Test]
-        public void Measure_NegativeScaleY()
+        public void FlipVerticalAppliesCorrectScale()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 1,
-                    ScaleY = -3
-                })
-                .MeasureElement(new Size(800, 600))
-                .ExpectChildMeasure(new Size(800, 200), SpacePlan.FullRender(800, 100))
-                .CheckMeasureResult(SpacePlan.FullRender(800, 300));
-        }
+            var container = EmptyContainer.Create();
         
-        #endregion
+            container.FlipVertical();
         
-        #region draw
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(1));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(-1));
+        }
         
         [Test]
-        public void Draw_Simple()
+        public void FlipOverAppliesCorrectScale()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 3,
-                    ScaleY = 2
-                })
-                .DrawElement(new Size(900, 800))
-                .ExpectCanvasTranslate(0, 0)
-                .ExpectCanvasScale(3, 2)
-                .ExpectChildDraw(new Size(300, 400))
-                .ExpectCanvasScale(1/3f, 1/2f)
-                .ExpectCanvasTranslate(0, 0)
-                .CheckDrawResult();
+            var container = EmptyContainer.Create();
+        
+            container.FlipOver();
+        
+            var rowContainer = container.Child as Scale;
+            Assert.That(rowContainer?.ScaleX, Is.EqualTo(-1));
+            Assert.That(rowContainer?.ScaleY, Is.EqualTo(-1));
         }
         
+        #endregion
+
+        #region Zero Scale Validation
+
         [Test]
-        public void Draw_NegativeScaleX()
+        public void ScaleCannotBeZero()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = -3,
-                    ScaleY = 2
-                })
-                .DrawElement(new Size(900, 800))
-                .ExpectCanvasTranslate(900, 0)
-                .ExpectCanvasScale(-3, 2)
-                .ExpectChildDraw(new Size(300, 400))
-                .ExpectCanvasScale(-1/3f, 1/2f)
-                .ExpectCanvasTranslate(-900, 0)
-                .CheckDrawResult();
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                EmptyContainer.Create().Scale(0);
+            });
+            
+            Assert.That(exception.Message, Is.EqualTo("Vertical scale factor cannot be zero. (Parameter 'factor')"));
         }
         
         [Test]
-        public void Draw_NegativeScaleY()
+        public void VerticalScaleCannotBeZero()
         {
-            TestPlan
-                .For(x => new Scale
-                {
-                    Child = x.CreateChild(),
-                    ScaleX = 3,
-                    ScaleY = -2
-                })
-                .DrawElement(new Size(900, 800))
-                .ExpectCanvasTranslate(0, 800)
-                .ExpectCanvasScale(3, -2)
-                .ExpectChildDraw(new Size(300, 400))
-                .ExpectCanvasScale(1/3f, -1/2f)
-                .ExpectCanvasTranslate(0, -800)
-                .CheckDrawResult();
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                EmptyContainer.Create().ScaleVertical(0);
+            });
+            
+            Assert.That(exception.Message, Is.EqualTo("Vertical scale factor cannot be zero. (Parameter 'factor')"));
         }
         
+        [Test]
+        public void HorizontalScaleCannotBeZero()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                EmptyContainer.Create().ScaleHorizontal(0);
+            });
+            
+            Assert.That(exception.Message, Is.EqualTo("Vertical scale factor cannot be zero. (Parameter 'factor')"));
+        }
+
         #endregion
     }
 }