Add more tests for the Padding element

Source/QuestPDF.LayoutTests/PaddingTests.cs

@@ -0,0 +1,198 @@
+namespace QuestPDF.LayoutTests;
+
+[TestFixture]
+public class PaddingTests
+{
+    [Test]
+    public void PaddingModifiesPositioningAndMinimumSize()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 100)
+            .ForContent(content =>
+            {
+                content
+                    .Shrink()
+                    .PaddingLeft(5)
+                    .PaddingTop(10)
+                    .PaddingRight(15)
+                    .PaddingBottom(20)
+                    .Mock("a")
+                    .SolidBlock(20, 30);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(40, 60)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(5, 10).Size(20, 30);
+                    });
+            });
+    }
+    
+    [Test]
+    public void NegativePaddingIsAllowed()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 100)
+            .ForContent(content =>
+            {
+                content
+                    .Shrink()
+                    .Padding(-10)
+                    .Mock("a")
+                    .SolidBlock(50, 70);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(30, 50)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(-10, -10).Size(50, 70);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PaddingSupportsPaging()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 100)
+            .ForContent(content =>
+            {
+                content
+                    .Shrink()
+                    .Padding(15)
+                    .Mock("a")
+                    .ContinuousBlock(50, 90);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(80, 100)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(15, 15).Size(50, 70);
+                    });
+                
+                document
+                    .Page()
+                    .RequiredAreaSize(80, 50)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(15, 15).Size(50, 20);
+                    });
+            });
+    }
+    
+    [Test]
+    public void MultipleItemsWithAppliedPadding()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Column(column =>
+                {
+                    column.Item().PaddingVertical(5).Mock("a").SolidBlock(15, 25);
+                    column.Item().PaddingHorizontal(10).Mock("b").SolidBlock(20, 30);
+                    column.Item().Padding(15).Mock("c").SolidBlock(25, 35);
+                });
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(55, 130)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 5).Size(55, 25);
+                        page.Mock("b").Position(10, 35).Size(35, 30);
+                        page.Mock("c").Position(15, 80).Size(25, 35);
+                    });
+            });
+    }
+    
+    [Test]
+    public void PaddingProducesAvailableSpaceOfNegativeSize()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Padding(60).SolidBlock(20, 25);
+            })
+            .ExpectLayoutException("The available space is negative.");
+    }
+    
+    [Test]
+    public void PaddingWithEmptyChild()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Padding(30);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(60, 60);
+            });
+    }
+    
+    [Test]
+    public void PaddingOnEmptyElementProducesAvailableSpaceOfNegativeSize()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Padding(60);
+            })
+            .ExpectLayoutException("The available space is negative.");
+    }
+    
+    [Test]
+    public void PaddingOnEmptyElementProducesAvailableSpaceOfNegativeSize2()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Padding(60).Column(column => { });
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(0, 0);
+            });
+    }
+    
+    [Test]
+    public void NegativePaddingProducesMeasurementOfNegativeSize()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(100, 150)
+            .ForContent(content =>
+            {
+                content.Shrink().Padding(-15).Mock("a").SolidBlock(20, 40);
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(0, 10)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(-15, -15).Size(30, 40);
+                    });
+            });
+    }
+}

Source/QuestPDF.LayoutTests/TestEngine/LayoutTest.cs

@@ -146,7 +146,7 @@ internal class LayoutTest
         }
     }
 
-    public void ExpectLayoutException()
+    public void ExpectLayoutException(string? reason = null)
     {
         try
         {
@@ -155,6 +155,7 @@ internal class LayoutTest
         }
         catch (DocumentLayoutException e)
         {
+            Assert.That(e.Message.Contains(reason));
             Assert.Pass($"The expected exception was thrown: {e.Message}");
         }
         catch

Source/QuestPDF.UnitTests/PaddingTests.cs

@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
+using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 
@@ -9,79 +10,232 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class PaddingTests
     {
-        private Padding GetPadding(TestPlan plan)
-        {
-            return new Padding()
-            {
-                Top = 10,
-                Right = 20,
-                Bottom = 30,
-                Left = 40,
-                
-                Child = plan.CreateChild()
-            };
+        [TestCase(0, 0, 0, 0, "")]
+        [TestCase(10, 0, 0, 0, "L=10")]
+        [TestCase(0, 15, 0, 0, "T=15")]
+        [TestCase(0, 0, 20, 0, "R=20")]
+        [TestCase(0, 0, 0, 25, "B=25")]
+        [TestCase(50, 0, 50, 0, "H=50")]
+        [TestCase(0, 60, 0, 60, "V=60")]
+        [TestCase(10, -20, 10, -30, "L=10   T=-20   R=10   B=-30")]
+        [TestCase(-5, -10, 15, -10, "L=-5   T=-10   R=15   B=-10")]
+        [TestCase(1.234f, -2.345f, 3.456f, -4.567f, "L=1.2   T=-2.3   R=3.5   B=-4.6")]
+        [TestCase(5, 5, 5, 5, "A=5")]
+        public void CompanionHint(float left, float top, float right, float bottom, string expected)
+        {
+            var container = EmptyContainer.Create();
+            
+            container
+                .PaddingLeft(left)
+                .PaddingTop(top)
+                .PaddingRight(right)
+                .PaddingBottom(bottom);
+            
+            var translationElement = container.Child as Padding;
+            var companionHint = translationElement?.GetCompanionHint();
+            
+            Assert.That(companionHint, Is.EqualTo(expected));
+        }
+        
+        #region Cumulative Property
+        
+        [Test]
+        public void PaddingLeftIsCumulative()
+        {
+            var container = EmptyContainer.Create();
+        
+            container.PaddingLeft(-20).PaddingLeft(25).PaddingLeft(30);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(35));
+        }
+        
+        [Test]
+        public void PaddingTopIsCumulative()
+        {
+            var container = EmptyContainer.Create();
+        
+            container.PaddingTop(20).PaddingTop(-25).PaddingTop(30);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Top, Is.EqualTo(25));
+        }
+        
+        [Test]
+        public void PaddingRightIsCumulative()
+        {
+            var container = EmptyContainer.Create();
+        
+            container.PaddingRight(20).PaddingRight(25).PaddingRight(-30);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Right, Is.EqualTo(15));
+        }
+        
+        [Test]
+        public void PaddingBottomIsCumulative()
+        {
+            var container = EmptyContainer.Create();
+        
+            container.PaddingBottom(-20).PaddingBottom(-25).PaddingBottom(30);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(-15));
         }
+        
+        #endregion
+        
+        #region Simple Asignment
+        
+        [Test]
+        public void PaddingVerticalShorthandWorksCorrectly()
+        {
+            var container = EmptyContainer.Create();
 
+            container.PaddingVertical(123);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(0));
+            Assert.That(rowContainer?.Top, Is.EqualTo(123));
+            Assert.That(rowContainer?.Right, Is.EqualTo(0));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(123));
+        }
+        
         [Test]
-        public void Measure_General_EnoughSpace()
+        public void PaddingHorizontalShorthandWorksCorrectly()
         {
-            TestPlan
-                .For(GetPadding)
-                .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.FullRender(140, 60))
-                .CheckMeasureResult(SpacePlan.FullRender(200, 100));
-        } 
+            var container = EmptyContainer.Create();
+
+            container.PaddingHorizontal(234);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(234));
+            Assert.That(rowContainer?.Top, Is.EqualTo(0));
+            Assert.That(rowContainer?.Right, Is.EqualTo(234));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(0));
+        }
         
         [Test]
-        public void Measure_NotEnoughWidth()
+        public void PaddingAllShorthandWorksCorrectly()
         {
-            TestPlan
-                .For(GetPadding)
-                .MeasureElement(new Size(50, 300))
-                .ExpectChildMeasure(Size.Zero, SpacePlan.PartialRender(Size.Zero))
-                .CheckMeasureResult(SpacePlan.Wrap("The available space is negative."));
+            var container = EmptyContainer.Create();
+
+            container.Padding(456);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(456));
+            Assert.That(rowContainer?.Top, Is.EqualTo(456));
+            Assert.That(rowContainer?.Right, Is.EqualTo(456));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(456));
         }
         
+        #endregion
+        
+        #region Unit Conversion
+        
         [Test]
-        public void Measure_NotEnoughHeight()
+        public void PaddingLeftAppliesUnitConversion()
         {
-            TestPlan
-                .For(GetPadding)
-                .MeasureElement(new Size(20, 300))
-                .ExpectChildMeasure(Size.Zero, SpacePlan.PartialRender(Size.Zero))
-                .CheckMeasureResult(SpacePlan.Wrap("The available space is negative."));
+            var container = EmptyContainer.Create();
+
+            container.PaddingLeft(2, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(144));
         }
         
         [Test]
-        public void Measure_AcceptsPartialRender()
+        public void PaddingTopAppliesUnitConversion()
         {
-            TestPlan
-                .For(GetPadding)
-                .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.PartialRender(40, 160))
-                .CheckMeasureResult(SpacePlan.PartialRender(100, 200));
+            var container = EmptyContainer.Create();
+
+            container.PaddingTop(3, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Top, Is.EqualTo(216));
         }
         
         [Test]
-        public void Measure_AcceptsWrap()
+        public void PaddingRightAppliesUnitConversion()
         {
-            TestPlan
-                .For(GetPadding)
-                .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.Wrap("Mock"))
-                .CheckMeasureResult(SpacePlan.Wrap("Forwarded from child"));
+            var container = EmptyContainer.Create();
+
+            container.PaddingRight(4, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Right, Is.EqualTo(288));
         }
         
         [Test]
-        public void Draw_General()
-        {
-            TestPlan
-                .For(GetPadding)
-                .DrawElement(new Size(400, 300))
-                .ExpectCanvasTranslate(new Position(40, 10))
-                .ExpectChildDraw(new Size(340, 260))
-                .ExpectCanvasTranslate(new Position(-40, -10))
-                .CheckDrawResult();
+        public void PaddingBottomAppliesUnitConversion()
+        {
+            var container = EmptyContainer.Create();
+
+            container.PaddingBottom(5, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(360));
+        }
+        
+        [Test]
+        public void PaddingVerticalAppliesUnitConversion()
+        {
+            var container = EmptyContainer.Create();
+
+            container.PaddingVertical(6, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Top, Is.EqualTo(432));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(432));
+        }
+        
+        [Test]
+        public void PaddingHorizontalAppliesUnitConversion()
+        {
+            var container = EmptyContainer.Create();
+
+            container.PaddingHorizontal(7, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(504));
+            Assert.That(rowContainer?.Right, Is.EqualTo(504));
+        }
+        
+        [Test]
+        public void PaddingAllAppliesUnitConversion()
+        {
+            var container = EmptyContainer.Create();
+
+            container.Padding(8, Unit.Inch);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(576));
+            Assert.That(rowContainer?.Top, Is.EqualTo(576));
+            Assert.That(rowContainer?.Right, Is.EqualTo(576));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(576));
+        }
+        
+        #endregion
+        
+        [Test]
+        public void PaddingAppliesCorrectValues()
+        {
+            var container = EmptyContainer.Create();
+
+            container
+                .PaddingLeft(20)
+                .PaddingTop(25)
+                .PaddingRight(30)
+                .PaddingBottom(35)
+                .PaddingVertical(-5)
+                .PaddingHorizontal(-15)
+                .Padding(10);
+        
+            var rowContainer = container.Child as Padding;
+            Assert.That(rowContainer?.Left, Is.EqualTo(15));
+            Assert.That(rowContainer?.Top, Is.EqualTo(30));
+            Assert.That(rowContainer?.Right, Is.EqualTo(25));
+            Assert.That(rowContainer?.Bottom, Is.EqualTo(40));
         }
     }
 }