update: bump code coverage

Author: mrdav30

AGENTS.md

@@ -37,10 +37,11 @@
 - Tests are xUnit (`tests/FixedMathSharp.Tests`). Keep one feature area per test file (e.g., `Vector3d.Tests.cs`, `Bounds/BoundingBox.Tests.cs`).
 - Use helper assertions from `tests/FixedMathSharp.Tests/Support/FixedMathTestHelper.cs` for tolerance/range checks rather than ad-hoc epsilon logic.
 - For deterministic RNG changes, validate same-seed reproducibility and bounds/argument exceptions like in `DeterministicRandom.Tests.cs`.
+- Cyclomatic complexity exceptions are documented in `docs/complexity-exceptions.md`; update that register when touching methods above the review threshold instead of refactoring hot deterministic paths just to lower a metric.
 
 ## Agent editing guidance
 
 - Keep public API shape stable unless the task explicitly requests API changes.
 - Match existing style (regions, XML docs, explicit namespaces, no implicit usings).
 - Make focused edits in the relevant numeric/bounds module and update corresponding tests in the parallel test file.
-- For serialization changes, ensure MemoryPack attributes are correctly applied and roundtrip tests are updated.
+- For serialization changes, ensure MemoryPack attributes are correctly applied and roundtrip tests are updated.

README.md

@@ -194,6 +194,8 @@ FixedMathSharp is optimized for high-performance deterministic calculations:
 
 The library is covered by xUnit tests for core arithmetic, vectors, bounds, serialization, and deterministic random behavior. Fuzzy comparisons are used where a tolerance-based check is more appropriate than exact equality.
 
+Cyclomatic complexity exceptions are tracked in [`docs/complexity-exceptions.md`](docs/complexity-exceptions.md). The register explains why specific hot-path or fixed-shape methods exceed the review threshold and what should trigger revisiting them.
+
 To run the tests:
 
 ```bash

docs/complexity-exceptions.md

@@ -0,0 +1,53 @@
+# Cyclomatic Complexity Exception Register
+
+This document records methods that intentionally exceed the current cyclomatic complexity review threshold.
+
+## Policy
+
+- Review threshold: cyclomatic complexity greater than 10.
+- Risk threshold: CRAP score greater than 30 requires immediate test hardening or refactoring.
+- Current status: the fresh coverage/CRAP report generated on 2026-05-18 has no methods above CRAP 30.
+- Source report: `tests/FixedMathSharp.Tests/TestResults/coverage-analysis/reports/Summary.txt`.
+
+Complexity exceptions are acceptable when the method is a hot deterministic math path, a direct component-wise value comparison, a fixed-shape assertion helper, or an algorithm where extraction would add indirection without reducing real maintenance risk. These exceptions should be revisited when coverage drops, behavior changes, or the implementation becomes harder to reason about.
+
+## Exception Register
+
+| Module | Method | Complexity | Coverage | Rationale | Revisit if |
+| --- | --- | ---: | --- | --- | --- |
+| `FixedMathSharp.FluentAssertions` | `FixedAssertionHelpers.AreComponentApproximatelyEqual(Fixed4x4, Fixed4x4, Fixed64)` | 30 | 100% line / 100% branch | Fixed-shape assertion over all matrix components. The explicit checks keep failure location and assertion intent clear. | Assertion diagnostics degrade, matrix shape changes, or repeated assertion logic grows further. |
+| `FixedMathSharp` | `Fixed4x4.Equals(Fixed4x4)` | 30 | 100% line / 100% branch | Direct 4x4 value comparison avoids loops, allocations, and indexer overhead on a hot value type. | Equality semantics change or a generated/source-shared component comparison becomes available without runtime cost. |
+| `FixedMathSharp` | `BoundingSphere.CreateFromPointList(IReadOnlyList<Vector3d>)` | 26 | 98.2% line / 100% branch | Ritter-style bounding sphere construction has fixed selection and expansion branches; keeping it local preserves data flow and avoids extra passes. | More sphere construction modes are added, coverage drops, or the algorithm needs accuracy/performance tuning. |
+| `FixedMathSharp` | `FixedMath.Sin(Fixed64)` | 24 | 100% line / 100% branch | Trigonometric range reduction and approximation are performance-sensitive and deterministic. Extraction would split a compact numeric routine. | Approximation strategy changes or benchmark evidence shows a helper split is neutral or faster. |
+| `FixedMathSharp` | `Fixed64.op_Division(Fixed64, Fixed64)` | 24 | 100% line / 100% branch | Saturating fixed-point division uses low-level bit operations and guarded overflow paths that should remain explicit. | Division semantics change or additional edge cases make the method difficult to audit. |
+| `FixedMathSharp` | `FixedMath.Sqrt(Fixed64)` | 18 | 100% line / 100% branch | Integer square-root logic is branchy by nature and sits on a core deterministic math path. | A simpler algorithm is adopted with equal determinism and performance. |
+| `FixedMathSharp` | `Fixed3x3Extensions.FuzzyEqual(Fixed3x3, Fixed3x3, Fixed64?)` | 18 | 100% line / 100% branch | Component-wise fuzzy equality is intentionally explicit to avoid allocation and preserve inlining. | The matrix equality helpers are generated or centralized without adding runtime overhead. |
+| `FixedMathSharp` | `BoundingSphere.ContainsBoxLike(Vector3d, Vector3d)` | 18 | 100% line / 100% branch | Checks all box-like corners against the sphere; explicit shape avoids temporary corner arrays. | Bounds internals move to a shared corner iterator that is allocation-free. |
+| `FixedMathSharp` | `Fixed4x4.get_Item(int)` | 17 | 100% line / 100% branch | Switch-based fixed matrix indexing is direct and avoids table allocation or reflection. | The matrix layout changes or generated indexer code becomes part of the build. |
+| `FixedMathSharp` | `Fixed4x4.set_Item(int, Fixed64)` | 17 | 100% line / 100% branch | Switch-based fixed matrix indexing is direct and avoids table allocation or reflection. | The matrix layout changes or generated indexer code becomes part of the build. |
+| `FixedMathSharp` | `Fixed64.op_Multiply(Fixed64, Fixed64)` | 16 | 95.6% line / 81.2% branch | Full-width multiply with saturating and round-half-to-even behavior requires explicit guarded paths. | Additional uncovered reachable branches appear, arithmetic semantics change, or benchmarks support a simpler equivalent. |
+| `FixedMathSharp` | `Fixed3x3Extensions.FuzzyEqualAbsolute(Fixed3x3, Fixed3x3, Fixed64)` | 16 | 100% line / 100% branch | Direct component-wise comparison avoids loops and keeps the extension inlinable. | The matrix equality helpers are generated or centralized without adding runtime overhead. |
+| `FixedMathSharp` | `Fixed3x3.Equals(Fixed3x3)` | 16 | 100% line / 100% branch | Direct 3x3 value comparison avoids loops, allocations, and indexer overhead on a hot value type. | Equality semantics change or a generated/source-shared component comparison becomes available without runtime cost. |
+| `FixedMathSharp` | `FixedCurve.Evaluate(Fixed64)` | 16 | 95.2% line / 87.5% branch | Curve evaluation combines clamping, segment search, and interpolation mode dispatch in one readable flow. | More interpolation modes are added or segment lookup becomes a performance bottleneck. |
+| `FixedMathSharp` | `FixedMath.Pow2(Fixed64)` | 16 | 100% line / 100% branch | Fixed-point exponent approximation is compact, deterministic, and performance-sensitive. | Approximation strategy changes or benchmark evidence supports decomposition. |
+| `FixedMathSharp` | `FixedPlane.IntersectsBoxLike(Vector3d, Vector3d)` | 16 | 100% line / 100% branch | Plane-vs-bounds classification is branch-heavy but fixed-shape and allocation-free. | Additional bound shapes are added and a shared allocation-free helper becomes clearer. |
+| `FixedMathSharp` | `BoundingFrustum.Intersects(FixedRay)` | 16 | 100% line / 93.8% branch | Slab-style frustum clipping has unavoidable enter/exit branches and benefits from locality. | More ray/frustum edge cases are discovered or clipping logic is shared elsewhere. |
+| `FixedMathSharp` | `FixedMath.Atan(Fixed64)` | 16 | 100% line / 100% branch | Trigonometric approximation and range handling are deterministic hot-path math. | Approximation strategy changes or benchmark evidence supports decomposition. |
+| `FixedMathSharp` | `FixedMath.Asin(Fixed64)` | 16 | 100% line / 100% branch | Trigonometric domain handling and approximation are deterministic hot-path math. | Approximation strategy changes or benchmark evidence supports decomposition. |
+| `FixedMathSharp` | `FixedMath.Tan(Fixed64)` | 16 | 95.6% line / 100% branch | Tangent delegates through fixed trigonometric identities and guarded edge handling. | New domain behavior is added or uncovered lines become reachable with valid input. |
+| `FixedMathSharp.FluentAssertions` | `FixedAssertionHelpers.AreComponentApproximatelyEqual(Fixed3x3, Fixed3x3, Fixed64)` | 16 | 100% line / 100% branch | Fixed-shape assertion over all matrix components. The explicit checks keep failure location and assertion intent clear. | Assertion diagnostics degrade, matrix shape changes, or repeated assertion logic grows further. |
+| `FixedMathSharp` | `BoundingFrustum.IntersectsFrustum(BoundingFrustum)` | 14 | 91.3% line / 85.7% branch | Separating-axis frustum checks are algorithmically branch-heavy and intentionally avoid allocations. | A robust shared SAT helper can improve clarity without extra allocations or worse benchmarks. |
+| `FixedMathSharp` | `BoundingBox.ClosestPointOnSurface(Vector3d)` | 14 | 100% line / 100% branch | The nearest-face selection is fixed-shape and explicit; helper extraction would not reduce real complexity. | Box surface projection grows beyond nearest-face selection. |
+| `FixedMathSharp` | `Fixed3x3.get_Item(int)` | 12 | 100% line / 100% branch | Switch-based fixed matrix indexing is direct and avoids table allocation or reflection. | The matrix layout changes or generated indexer code becomes part of the build. |
+| `FixedMathSharp` | `Fixed3x3.set_Item(int, Fixed64)` | 12 | 100% line / 100% branch | Switch-based fixed matrix indexing is direct and avoids table allocation or reflection. | The matrix layout changes or generated indexer code becomes part of the build. |
+| `FixedMathSharp` | `BoundingFrustum.Contains(BoundingFrustum)` | 12 | 100% line / 100% branch | Frustum containment needs null handling, equality fast-path, corner checks, and intersection fallback. | Frustum containment semantics change or the corner loop is shared with other bound types. |
+| `FixedMathSharp` | `FixedMath.Acos(Fixed64)` | 12 | 100% line / 100% branch | Trigonometric domain handling and approximation are deterministic hot-path math. | Approximation strategy changes or benchmark evidence supports decomposition. |
+| `FixedMathSharp` | `FixedQuaternion.FromEulerAngles(Fixed64, Fixed64, Fixed64)` | 12 | 100% line / 100% branch | Validates three angles and builds the quaternion in a compact deterministic path. | Angle validation policy changes or Euler conversion variants are added. |
+| `FixedMathSharp` | `FixedRay.Intersects(BoundingSphere)` | 12 | 100% line / 91.7% branch | Ray-sphere intersection has standard geometric early exits and should remain local for clarity and speed. | New ray semantics are added or branch gaps reveal reachable untested behavior. |
+
+## Review Notes
+
+- Methods at 100% line and branch coverage with direct component-wise logic should usually remain explicit unless a zero-overhead generated approach is introduced.
+- For fixed-point arithmetic and trigonometric routines, prefer benchmark-backed refactors over structural changes made only to reduce the reported complexity number.
+- If a method remains above the complexity threshold and below full branch coverage, prefer adding focused tests for reachable branches before refactoring.
+- Re-run coverage and CRAP analysis after any changes that touch the methods listed above, then update this register.

src/FixedMathSharp/Geometry/Bounds/BoundingSphere.cs

@@ -155,9 +155,6 @@ public static BoundingSphere CreateMerged(BoundingSphere original, BoundingSpher
             if (distance + original.Radius <= additional.Radius)
                 return additional;
 
-            if (distance == Fixed64.Zero)
-                return original.Radius >= additional.Radius ? original : additional;
-
             Fixed64 radius = (distance + original.Radius + additional.Radius) * Fixed64.Half;
             Vector3d center = original.Center + centerOffset * ((radius - original.Radius) / distance);
 

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

@@ -59,6 +59,7 @@ public void MinMaxDimensionsAndBounds_AreCorrect_WhenCornersAreReversed()
         Assert.Equal(new Fixed64(3), area.Width);
         Assert.Equal(new Fixed64(3), area.Height);
         Assert.Equal(new Fixed64(3), area.Depth);
+        Assert.Equal(new Fixed64(5), new BoundingArea(new Vector3d(1, 5, 3), new Vector3d(4, 2, 6)).MaxY);
     }
 
     [Fact]
@@ -170,11 +171,21 @@ public void Intersects_WithBoundingFrustum_ReturnsTrueOnlyWhenOverlapping()
         Assert.False(disjoint.Intersects(frustum));
     }
 
+    [Fact]
+    public void ContainsAndIntersects_NullFrustum_Throw()
+    {
+        var area = new BoundingArea(new Vector3d(-1, -1, -1), new Vector3d(1, 1, 1));
+
+        Assert.Throws<System.ArgumentNullException>(() => area.Contains((BoundingFrustum)null!));
+        Assert.Throws<System.ArgumentNullException>(() => area.Intersects((BoundingFrustum)null!));
+    }
+
     [Fact]
     public void Contains_TypedBounds_ReturnsContainmentClassification()
     {
         var area = new BoundingArea(new Vector3d(-2, -2, 0), new Vector3d(2, 2, 2));
         var containedArea = new BoundingArea(new Vector3d(-1, -1, 0), new Vector3d(1, 1, 1));
+        var disjointArea = new BoundingArea(new Vector3d(5, 5, 5), new Vector3d(6, 6, 6));
         var crossingBox = new BoundingBox(new Vector3d(2, 0, 1), new Vector3d(2, 1, 1));
         var containedSphere = new BoundingSphere(new Vector3d(0, 0, 1), Fixed64.Half);
         var crossingSphere = new BoundingSphere(new Vector3d(2, 0, 1), Fixed64.One);
@@ -183,14 +194,19 @@ public void Contains_TypedBounds_ReturnsContainmentClassification()
         var crossingFrustumMatrix = Fixed4x4.Identity;
         crossingFrustumMatrix.m30 = Fixed64.Two;
         var crossingFrustum = new BoundingFrustum(crossingFrustumMatrix);
+        var disjointFrustumMatrix = Fixed4x4.Identity;
+        disjointFrustumMatrix.m30 = new Fixed64(6);
+        var disjointFrustum = new BoundingFrustum(disjointFrustumMatrix);
 
         Assert.Equal(ContainmentType.Contains, area.Contains(containedArea));
+        Assert.Equal(ContainmentType.Disjoint, area.Contains(disjointArea));
         Assert.Equal(ContainmentType.Intersects, area.Contains(crossingBox));
         Assert.Equal(ContainmentType.Contains, area.Contains(containedSphere));
         Assert.Equal(ContainmentType.Intersects, area.Contains(crossingSphere));
         Assert.Equal(ContainmentType.Disjoint, area.Contains(disjointSphere));
         Assert.Equal(ContainmentType.Contains, area.Contains(containedFrustum));
         Assert.Equal(ContainmentType.Intersects, area.Contains(crossingFrustum));
+        Assert.Equal(ContainmentType.Disjoint, area.Contains(disjointFrustum));
     }
 
     [Fact]
@@ -220,6 +236,66 @@ public void Intersects_FlatYZAreas_ReturnsTrue()
         Assert.True(area1.Intersects(area2));
     }
 
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    public void Intersects_FlatXYAreas_ReturnsFalseForEachSeparatedAxisSide(int separatedSide)
+    {
+        var area = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(4, 4, 0));
+        BoundingArea other = separatedSide switch
+        {
+            0 => new BoundingArea(new Vector3d(5, 1, 0), new Vector3d(6, 3, 0)),
+            1 => new BoundingArea(new Vector3d(-6, 1, 0), new Vector3d(-5, 3, 0)),
+            2 => new BoundingArea(new Vector3d(1, 5, 0), new Vector3d(3, 6, 0)),
+            3 => new BoundingArea(new Vector3d(1, -6, 0), new Vector3d(3, -5, 0)),
+            _ => throw new System.ArgumentOutOfRangeException(nameof(separatedSide)),
+        };
+
+        Assert.False(area.Intersects(other));
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    public void Intersects_FlatXZAreas_ReturnsFalseForEachSeparatedAxisSide(int separatedSide)
+    {
+        var area = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(4, 0, 4));
+        BoundingArea other = separatedSide switch
+        {
+            0 => new BoundingArea(new Vector3d(5, 0, 1), new Vector3d(6, 0, 3)),
+            1 => new BoundingArea(new Vector3d(-6, 0, 1), new Vector3d(-5, 0, 3)),
+            2 => new BoundingArea(new Vector3d(1, 0, 5), new Vector3d(3, 0, 6)),
+            3 => new BoundingArea(new Vector3d(1, 0, -6), new Vector3d(3, 0, -5)),
+            _ => throw new System.ArgumentOutOfRangeException(nameof(separatedSide)),
+        };
+
+        Assert.False(area.Intersects(other));
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(3)]
+    public void Intersects_FlatYZAreas_ReturnsFalseForEachSeparatedAxisSide(int separatedSide)
+    {
+        var area = new BoundingArea(new Vector3d(0, 0, 0), new Vector3d(0, 4, 4));
+        BoundingArea other = separatedSide switch
+        {
+            0 => new BoundingArea(new Vector3d(0, 5, 1), new Vector3d(0, 6, 3)),
+            1 => new BoundingArea(new Vector3d(0, -6, 1), new Vector3d(0, -5, 3)),
+            2 => new BoundingArea(new Vector3d(0, 1, 5), new Vector3d(0, 3, 6)),
+            3 => new BoundingArea(new Vector3d(0, 1, -6), new Vector3d(0, 3, -5)),
+            _ => throw new System.ArgumentOutOfRangeException(nameof(separatedSide)),
+        };
+
+        Assert.False(area.Intersects(other));
+    }
+
     [Fact]
     public void ProjectPoint_ClampsPointWithinBounds()
     {
@@ -292,6 +368,7 @@ public void Inequality_AndObjectEqualityBehaveCorrectly()
         var area2 = new BoundingArea(new Vector3d(1, 2, 3), new Vector3d(4, 5, 7));
 
         Assert.True(area1 != area2);
+        Assert.True(area1.Equals((object)new BoundingArea(new Vector3d(1, 2, 3), new Vector3d(4, 5, 6))));
         Assert.False(area1.Equals("not-an-area"));
     }