Add tests for the Row element

Source/QuestPDF.LayoutTests/RowTests.cs

@@ -389,7 +389,7 @@ public class RowTests
                 {
                     row.Spacing(200);
                     
-                    row.ConstantItem(10).Mock("a").SolidBlock(height: 40);
+                    row.ConstantItem(10).SolidBlock(height: 40); // <-
                 });
             })
             .ExpectLayoutException("The content requires more horizontal space than available.");
@@ -730,4 +730,59 @@ public class RowTests
     }
     
     #endregion
+    
+    #region Stateful
+    
+    [Test]
+    public void CheckRenderingState()
+    {
+        LayoutTest
+            .HavingSpaceOfSize(240, 100)
+            .ForContent(content =>
+            {
+                content.Shrink().Mock("a").Row(innerRow =>
+                {
+                    innerRow.RelativeItem().ContinuousBlock(50, 80);
+                    innerRow.RelativeItem().ContinuousBlock(50, 250);
+                    innerRow.RelativeItem().ContinuousBlock(50, 170);
+                    innerRow.RelativeItem().ContinuousBlock(50, 320);
+                });
+            })
+            .ExpectDrawResult(document =>
+            {
+                document
+                    .Page()
+                    .RequiredAreaSize(240, 100)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(240, 100).State(new[] { true, false, false, false });
+                    });
+                
+                document
+                    .Page()
+                    .RequiredAreaSize(240, 100)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(240, 100).State(new[] { true, false, true, false });
+                    });
+                
+                document
+                    .Page()
+                    .RequiredAreaSize(240, 100)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(240, 100).State(new[] { true, true, true, false });
+                    });
+                
+                document
+                    .Page()
+                    .RequiredAreaSize(240, 20)
+                    .Content(page =>
+                    {
+                        page.Mock("a").Position(0, 0).Size(240, 20).State(new[] { true, true, true, true });
+                    });
+            });
+    }
+    
+    #endregion
 }

Source/QuestPDF.UnitTests/RowTests.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.UnitTests;
+
+[TestFixture]
+public class RowTests
+{
+    #region Spacing
+    
+    [TestCase(float.MinValue)]
+    [TestCase(-5)]
+    [TestCase(-float.Epsilon)]
+    public void NegativeSpacingThrowsException(float spacingValue)
+    {
+        var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+        {
+            EmptyContainer
+                .Create()
+                .Row(row =>
+                {
+                    row.Spacing(spacingValue);
+                });
+        });
+        
+        Assert.That(exception.Message, Is.EqualTo("The row spacing cannot be negative. (Parameter 'spacing')"));
+    }
+    
+    [TestCase(0)]
+    [TestCase(float.Epsilon)]
+    [TestCase(10)]
+    public void ValidSpacingIsCorrectlyApplied(float spacingValue)
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.Spacing(spacingValue);
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Spacing, Is.EqualTo(spacingValue));
+    }
+    
+    [Test]
+    public void SpacingSupportsUnitConversion()
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.Spacing(5, Unit.Inch);
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Spacing, Is.EqualTo(360));
+    }
+    
+    #endregion
+    
+    #region Relative Item
+    
+    [TestCase(-10)]
+    [TestCase(-float.Epsilon)]
+    [TestCase(0)]
+    public void RelativeItemCannotHaveSizeSmallerOrEqualToZero(float size)
+    {
+        var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+        {
+            EmptyContainer
+                .Create()
+                .Row(row =>
+                {
+                    row.RelativeItem(size);
+                });
+        });
+
+        Assert.That(exception?.Message, Is.EqualTo("The relative item size must be greater than zero. (Parameter 'size')"));
+    }
+    
+    [TestCase(float.Epsilon)]
+    [TestCase(1)]
+    [TestCase(5)]
+    public void RelativeItemMustHaveSizeLargerThanZero(float size)
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.RelativeItem(size);
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Items.Count, Is.EqualTo(1));
+        
+        var firstItem = rowContainer?.Items.Single();
+        Assert.That(firstItem.Type, Is.EqualTo(RowItemType.Relative));
+        Assert.That(firstItem.Size, Is.EqualTo(size));
+    }
+    
+    #endregion
+    
+    #region Constant Item
+    
+    [TestCase(-10)]
+    [TestCase(-float.Epsilon)]
+    public void ConstantItemCannotHaveSizeSmallerThanZero(float size)
+    {
+        var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+        {
+            EmptyContainer
+                .Create()
+                .Row(row =>
+                {
+                    row.ConstantItem(size);
+                });
+        });
+
+        Assert.That(exception?.Message, Is.EqualTo("The constant item size cannot be negative. (Parameter 'size')"));
+    }
+    
+    [TestCase(0)]
+    [TestCase(100)]
+    public void ConstantItemMustHaveSizeLargerOrEqualToZero(float size)
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.ConstantItem(size);
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Items.Count, Is.EqualTo(1));
+        
+        var firstItem = rowContainer?.Items.Single();
+        Assert.That(firstItem.Type, Is.EqualTo(RowItemType.Constant));
+        Assert.That(firstItem.Size, Is.EqualTo(size));
+    }
+    
+    [Test]
+    public void ConstantItemSupportsUnitConversion()
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.ConstantItem(2, Unit.Inch);
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Items.Count, Is.EqualTo(1));
+        
+        var firstItem = rowContainer?.Items.Single();
+        Assert.That(firstItem.Type, Is.EqualTo(RowItemType.Constant));
+        Assert.That(firstItem.Size, Is.EqualTo(144));
+    }
+    
+    #endregion
+    
+    [Test]
+    public void CompanionHints()
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            row.RelativeItem(3);
+            row.ConstantItem(2, Unit.Inch);
+            row.AutoItem();
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Items.Count, Is.EqualTo(3));
+        
+        var items = rowContainer?.Items;
+        
+        Assert.That(items[0].GetCompanionHint(), Is.EqualTo("Relative 3"));
+        Assert.That(items[1].GetCompanionHint(), Is.EqualTo("Constant 144"));
+        Assert.That(items[2].GetCompanionHint(), Is.EqualTo("Auto"));
+    }
+    
+    [Test]
+    [Repeat(10)]
+    public void RowSupportsStatefulOperations()
+    {
+        var container = EmptyContainer.Create();
+        
+        container.Row(row =>
+        {
+            foreach (var i in Enumerable.Range(0, 10))
+                row.RelativeItem();
+        });
+        
+        var rowContainer = container.Child as Row;
+        Assert.That(rowContainer?.Items.Count, Is.EqualTo(10));
+        
+        rowContainer.ResetState();
+        Assert.That(rowContainer.GetState(), Is.EquivalentTo(new bool[10]));
+        
+        var newState = Enumerable
+            .Range(0, 10)
+            .Select(x => Random.Shared.Next() % 2 == 0)
+            .ToArray();
+        
+        rowContainer.SetState(newState);
+        Assert.That(rowContainer.GetState(), Is.EquivalentTo(newState));
+        
+        rowContainer.ResetState();
+        Assert.That(rowContainer.GetState(), Is.EquivalentTo(new bool[10]));
+    }
+}

Source/QuestPDF/Fluent/RowExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -12,12 +13,12 @@ namespace QuestPDF.Fluent
         /// <summary>
         /// Adjusts horizontal spacing between items.
         /// </summary>
-        public void Spacing(float value, Unit unit = Unit.Point)
+        public void Spacing(float spacing, Unit unit = Unit.Point)
         {
-            if (value < 0)
-                throw new ArgumentOutOfRangeException(nameof(value), "The row spacing cannot be negative.");
+            if (spacing < 0)
+                throw new ArgumentOutOfRangeException(nameof(spacing), "The row spacing cannot be negative.");
             
-            Row.Spacing = value.ToPoints(unit);
+            Row.Spacing = spacing.ToPoints(unit);
         }
 
         private IContainer Item(RowItemType type, float size = 0)
@@ -29,16 +30,18 @@ namespace QuestPDF.Fluent
             };
             
             Row.Items.Add(item);
-            return item.DebugPointer(DebugPointerType.ElementStructure, item.ToString());
+            return item;
         }
         
         [Obsolete("This element has been renamed since version 2022.2. Please use the RelativeItem method.")]
+        [ExcludeFromCodeCoverage]
         public IContainer RelativeColumn(float size = 1)
         {
             return Item(RowItemType.Relative, size);
         }
         
         [Obsolete("This element has been renamed since version 2022.2. Please use the ConstantItem method.")]
+        [ExcludeFromCodeCoverage]
         public IContainer ConstantColumn(float size)
         {
             return Item(RowItemType.Constant, size);
@@ -54,8 +57,8 @@ namespace QuestPDF.Fluent
         /// <returns>The container of the newly added item.</returns>
         public IContainer RelativeItem(float size = 1)
         {
-            if (size < 0)
-                throw new ArgumentOutOfRangeException(nameof(size), "The relative item size cannot be negative.");
+            if (size <= 0)
+                throw new ArgumentOutOfRangeException(nameof(size), "The relative item size must be greater than zero.");
             
             return Item(RowItemType.Relative, size);
         }