update: expand test coverage

Author: mrdav30

coverlet.runsettings

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RunSettings>
+  <DataCollectionRunSettings>
+    <DataCollectors>
+      <DataCollector friendlyName="XPlat Code Coverage">
+        <Configuration>
+          <ExcludeByFile>**/MemoryPack.Generator/**/*.cs,**/*MemoryPackFormatter.g.cs,**/*MemoryPackFormatterProvider.g.cs</ExcludeByFile>
+        </Configuration>
+      </DataCollector>
+    </DataCollectors>
+  </DataCollectionRunSettings>
+</RunSettings>

src/FixedMathSharp/Numerics/Fixed4x4.cs

@@ -1050,9 +1050,11 @@ public override int GetHashCode()
             hash = hash * 23 + m00.GetHashCode();
             hash = hash * 23 + m01.GetHashCode();
             hash = hash * 23 + m02.GetHashCode();
+            hash = hash * 23 + m03.GetHashCode();
             hash = hash * 23 + m10.GetHashCode();
             hash = hash * 23 + m11.GetHashCode();
             hash = hash * 23 + m12.GetHashCode();
+            hash = hash * 23 + m13.GetHashCode();
             hash = hash * 23 + m20.GetHashCode();
             hash = hash * 23 + m21.GetHashCode();
             hash = hash * 23 + m22.GetHashCode();
@@ -1066,4 +1068,4 @@ public override int GetHashCode()
     }
 
     #endregion    
-}
+}

tests/FixedMathSharp.Tests/Bounds/BoundingArea.Tests.cs

@@ -7,6 +7,24 @@ namespace FixedMathSharp.Tests.Bounds;
 
 public class BoundingAreaTests
 {
+    private readonly struct UnsupportedBound : IBound
+    {
+        public Vector3d Min { get; }
+        public Vector3d Max { get; }
+
+        public UnsupportedBound(Vector3d min, Vector3d max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        public bool Contains(Vector3d point) => false;
+
+        public bool Intersects(IBound other) => false;
+
+        public Vector3d ProjectPoint(Vector3d point) => point;
+    }
+
     #region Test: Constructor and Property
 
     [Fact]
@@ -21,6 +39,15 @@ public void Constructor_AssignsCornersCorrectly()
         Assert.Equal(corner2, area.Corner2);
     }
 
+    [Fact]
+    public void Constructor_WithScalarCorners_AssignsValuesCorrectly()
+    {
+        var area = new BoundingArea(Fixed64.One, new Fixed64(2), new Fixed64(3), new Fixed64(4), new Fixed64(5), new Fixed64(6));
+
+        Assert.Equal(new Vector3d(1, 2, 3), area.Corner1);
+        Assert.Equal(new Vector3d(4, 5, 6), area.Corner2);
+    }
+
     [Fact]
     public void MinMaxProperties_AreCorrect()
     {
@@ -37,6 +64,21 @@ public void MinMaxProperties_AreCorrect()
         Assert.Equal(new Fixed64(6), area.MaxZ);
     }
 
+    [Fact]
+    public void MinMaxDimensionsAndBounds_AreCorrect_WhenCornersAreReversed()
+    {
+        var area = new BoundingArea(
+            new Vector3d(5, 1, 6),
+            new Vector3d(2, 4, 3)
+        );
+
+        Assert.Equal(new Vector3d(2, 1, 3), area.Min);
+        Assert.Equal(new Vector3d(5, 4, 6), area.Max);
+        Assert.Equal(new Fixed64(3), area.Width);
+        Assert.Equal(new Fixed64(3), area.Height);
+        Assert.Equal(new Fixed64(3), area.Depth);
+    }
+
     #endregion
 
     #region Test: Containment
@@ -112,6 +154,52 @@ public void Intersects_WithBoundingSphere_ReturnsTrue()
         Assert.True(area.Intersects(sphere));
     }
 
+    [Fact]
+    public void Intersects_ReturnsTrue_WhenOtherBoundIsFullyContained()
+    {
+        var containing = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(10, 10, 10));
+        var contained = new BoundingArea(new Vector3d(2, 2, 2), new Vector3d(4, 4, 4));
+
+        Assert.True(containing.Intersects(contained));
+    }
+
+    [Fact]
+    public void Intersects_FlatXZAreas_ReturnsTrue()
+    {
+        var area1 = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(4, 0, 4));
+        var area2 = new BoundingArea(new Vector3d(2, 0, 2), new Vector3d(6, 0, 6));
+
+        Assert.True(area1.Intersects(area2));
+    }
+
+    [Fact]
+    public void Intersects_FlatYZAreas_ReturnsTrue()
+    {
+        var area1 = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(0, 4, 4));
+        var area2 = new BoundingArea(new Vector3d(0, 2, 2), new Vector3d(0, 6, 6));
+
+        Assert.True(area1.Intersects(area2));
+    }
+
+    [Fact]
+    public void Intersects_WithUnsupportedBound_ReturnsFalse()
+    {
+        var area = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(1, 1, 1));
+        var unsupported = new UnsupportedBound(new Vector3d(5, 5, 5), new Vector3d(6, 6, 6));
+
+        Assert.False(area.Intersects(unsupported));
+    }
+
+    [Fact]
+    public void ProjectPoint_ClampsPointWithinBounds()
+    {
+        var area = new BoundingArea(new Vector3d(1, 2, 3), new Vector3d(4, 5, 6));
+
+        var projected = area.ProjectPoint(new Vector3d(10, 1, 5));
+
+        Assert.Equal(new Vector3d(4, 2, 5), projected);
+    }
+
     #endregion
 
     #region Test: Equality
@@ -143,6 +231,16 @@ public void GetHashCode_SameArea_ReturnsSameHash()
         Assert.Equal(area1.GetHashCode(), area2.GetHashCode());
     }
 
+    [Fact]
+    public void Inequality_AndObjectEqualityBehaveCorrectly()
+    {
+        var area1 = new BoundingArea(new Vector3d(1, 2, 3), new Vector3d(4, 5, 6));
+        var area2 = new BoundingArea(new Vector3d(1, 2, 3), new Vector3d(4, 5, 7));
+
+        Assert.True(area1 != area2);
+        Assert.False(area1.Equals("not-an-area"));
+    }
+
     #endregion
 
     #region Test: Edge Cases

tests/FixedMathSharp.Tests/Bounds/BoundingBox.Tests.cs

@@ -7,6 +7,24 @@ namespace FixedMathSharp.Tests.Bounds;
 
 public class BoundingBoxTests
 {
+    private readonly struct UnsupportedBound : IBound
+    {
+        public Vector3d Min { get; }
+        public Vector3d Max { get; }
+
+        public UnsupportedBound(Vector3d min, Vector3d max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        public bool Contains(Vector3d point) => false;
+
+        public bool Intersects(IBound other) => false;
+
+        public Vector3d ProjectPoint(Vector3d point) => point;
+    }
+
     #region Test: Constructor and Property
 
     [Fact]
@@ -127,6 +145,14 @@ public void DistanceToSurface_WorksCorrectly()
         Assert.Equal(Fixed64.One, box.DistanceToSurface(point));
     }
 
+    [Fact]
+    public void DistanceToSurface_InsidePoint_ReturnsZero()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        Assert.Equal(Fixed64.Zero, box.DistanceToSurface(new Vector3d(1, 1, 1)));
+    }
+
     [Fact]
     public void ClosestPointOnSurface_ReturnsCorrectPoint()
     {
@@ -137,6 +163,36 @@ public void ClosestPointOnSurface_ReturnsCorrectPoint()
         Assert.Equal(new Vector3d(2, 2, 2), closestPoint);
     }
 
+    [Fact]
+    public void ClosestPointOnSurface_InsidePoint_UsesNearestFace()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        Assert.Equal(new Vector3d(-2, 0.5, 0.25), box.ClosestPointOnSurface(new Vector3d(-1.75, 0.5, 0.25)));
+        Assert.Equal(new Vector3d(0.25, 2, -0.75), box.ClosestPointOnSurface(new Vector3d(0.25, 1.9, -0.75)));
+        Assert.Equal(new Vector3d(-0.25, 0.5, -2), box.ClosestPointOnSurface(new Vector3d(-0.25, 0.5, -1.8)));
+    }
+
+    [Fact]
+    public void ProjectPoint_ClampsToBounds()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        var projected = box.ProjectPoint(new Vector3d(5, -3, 1));
+
+        Assert.Equal(new Vector3d(2, -2, 1), projected);
+    }
+
+    [Fact]
+    public void GetPointOnSurfaceTowardsObject_UsesProjectedPoint()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        var point = box.GetPointOnSurfaceTowardsObject(new Vector3d(5, 1, 0));
+
+        Assert.Equal(new Vector3d(2, 1, 0), point);
+    }
+
     #endregion
 
     #region Test: Equality
@@ -179,6 +235,23 @@ public void SetBoundingBox_KeepsSizeAndScopeInSync()
         Assert.Equal(newScope * Fixed64.Two, box.Proportions);
     }
 
+    [Fact]
+    public void Inequality_DifferentBox_ReturnsTrue()
+    {
+        var box1 = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+        var box2 = new BoundingBox(new Vector3d(1, 1, 1), new Vector3d(4, 4, 4));
+
+        Assert.True(box1 != box2);
+    }
+
+    [Fact]
+    public void Equals_WithDifferentObjectType_ReturnsFalse()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        Assert.False(box.Equals("not-a-box"));
+    }
+
     #endregion
 
     #region Test: Edge Cases
@@ -226,6 +299,55 @@ public void SetMinMax_SetsCorrectCenterAndSize()
         Assert.Equal(new Vector3d(4, 4, 4), box.Proportions);
     }
 
+    [Fact]
+    public void Center_Setter_RepositionsBoundsWithoutChangingSize()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 6, 8));
+
+        box.Center = new Vector3d(5, -1, 3);
+
+        Assert.Equal(new Vector3d(5, -1, 3), box.Center);
+        Assert.Equal(new Vector3d(4, 6, 8), box.Proportions);
+        Assert.Equal(new Vector3d(3, -4, -1), box.Min);
+        Assert.Equal(new Vector3d(7, 2, 7), box.Max);
+    }
+
+    [Fact]
+    public void Proportions_Setter_ResizesBoundsWithoutChangingCenter()
+    {
+        var box = new BoundingBox(new Vector3d(1, 2, 3), new Vector3d(4, 4, 4));
+
+        box.Proportions = new Vector3d(6, 8, 10);
+
+        Assert.Equal(new Vector3d(1, 2, 3), box.Center);
+        Assert.Equal(new Vector3d(-2, -2, -2), box.Min);
+        Assert.Equal(new Vector3d(4, 6, 8), box.Max);
+    }
+
+    [Fact]
+    public void Orient_WithNullSize_PreservesCurrentProportions()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 6, 8));
+
+        box.Orient(new Vector3d(10, 20, 30), null);
+
+        Assert.Equal(new Vector3d(10, 20, 30), box.Center);
+        Assert.Equal(new Vector3d(4, 6, 8), box.Proportions);
+    }
+
+    [Fact]
+    public void Orient_WithExplicitSize_UsesProvidedDimensions()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+
+        box.Orient(new Vector3d(1, 2, 3), new Vector3d(2, 4, 6));
+
+        Assert.Equal(new Vector3d(1, 2, 3), box.Center);
+        Assert.Equal(new Vector3d(2, 4, 6), box.Proportions);
+        Assert.Equal(new Vector3d(0, 0, 0), box.Min);
+        Assert.Equal(new Vector3d(2, 4, 6), box.Max);
+    }
+
     #endregion
 
     #region Test: Vertex Cache Safety
@@ -242,6 +364,38 @@ public void Vertices_UpdateAfterMutation()
         Assert.NotEqual(original, updated);
     }
 
+    [Fact]
+    public void Union_EnclosesBothBoxes()
+    {
+        var a = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(2, 2, 2));
+        var b = new BoundingBox(new Vector3d(4, 0, 0), new Vector3d(4, 4, 4));
+
+        var union = BoundingBox.Union(a, b);
+
+        Assert.Equal(new Vector3d(-1, -2, -2), union.Min);
+        Assert.Equal(new Vector3d(6, 2, 2), union.Max);
+    }
+
+    [Fact]
+    public void FindClosestPointsBetweenBoxes_ReturnsClosestPointOnFirstBoxSurface()
+    {
+        var a = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(2, 2, 2));
+        var b = new BoundingBox(new Vector3d(5, 0, 0), new Vector3d(2, 2, 2));
+
+        var closestPoint = BoundingBox.FindClosestPointsBetweenBoxes(a, b);
+
+        Assert.Equal(new Vector3d(1, -1, -1), closestPoint);
+    }
+
+    [Fact]
+    public void Intersects_WithUnsupportedBound_ReturnsFalse()
+    {
+        var box = new BoundingBox(new Vector3d(0, 0, 0), new Vector3d(4, 4, 4));
+        var unsupported = new UnsupportedBound(new Vector3d(10, 10, 10), new Vector3d(12, 12, 12));
+
+        Assert.False(box.Intersects(unsupported));
+    }
+
     #endregion
 
     #region Test: Serialization