update: wrap up coverage effort

Author: mrdav30

.github/workflows/coverage.yml

@@ -0,0 +1,98 @@
+name: Coverage
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: coverage-pages
+  cancel-in-progress: true
+
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: 8.0.x
+
+    - name: Cache NuGet packages
+      uses: actions/cache@v4
+      with:
+        path: ~/.nuget/packages
+        key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj', '**/*.sln') }}
+        restore-keys: |
+          ${{ runner.os }}-nuget-
+
+    - name: Restore dependencies
+      run: dotnet restore
+
+    - name: Build tests
+      run: dotnet build tests/FixedMathSharp.Tests/FixedMathSharp.Tests.csproj --configuration Debug --no-restore
+
+    - name: Run tests with coverage
+      run: dotnet test tests/FixedMathSharp.Tests/FixedMathSharp.Tests.csproj --configuration Debug --no-build --collect:"XPlat Code Coverage" --results-directory artifacts/coverage
+
+    - name: Install ReportGenerator
+      run: dotnet tool install --global dotnet-reportgenerator-globaltool
+
+    - name: Add ReportGenerator to PATH
+      run: echo "$HOME/.dotnet/tools" >> "$GITHUB_PATH"
+
+    - name: Generate coverage report
+      run: |
+        reportgenerator \
+          "-reports:artifacts/coverage/**/coverage.cobertura.xml" \
+          "-targetdir:artifacts/coverage-report" \
+          "-reporttypes:Html;MarkdownSummaryGithub;Badges;JsonSummary"
+
+    - name: Add coverage summary to job
+      run: cat artifacts/coverage-report/SummaryGithub.md >> "$GITHUB_STEP_SUMMARY"
+
+    - name: Upload coverage artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: coverage-report
+        path: artifacts/coverage-report
+
+  deploy:
+    if: github.event_name != 'pull_request' && github.ref == 'refs/heads/main'
+    needs: coverage
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    steps:
+    - name: Configure Pages
+      uses: actions/configure-pages@v5
+
+    - name: Download coverage artifact
+      uses: actions/download-artifact@v4
+      with:
+        name: coverage-report
+        path: artifacts/coverage-report
+
+    - name: Upload Pages artifact
+      uses: actions/upload-pages-artifact@v3
+      with:
+        path: artifacts/coverage-report
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v4

.gitignore

@@ -1,2 +1 @@
 .vs/
-src/FixedMathSharp/FixedMathSharp.csproj.user

README.md

@@ -3,6 +3,7 @@
 ![FixedMathSharp Icon](https://raw.githubusercontent.com/mrdav30/fixedmathsharp/main/icon.png)
 
 [![.NET CI](https://github.com/mrdav30/FixedMathSharp/actions/workflows/dotnet.yml/badge.svg)](https://github.com/mrdav30/FixedMathSharp/actions/workflows/dotnet.yml)
+[![Coverage](https://mrdav30.github.io/FixedMathSharp/badge_linecoverage.svg)](https://mrdav30.github.io/FixedMathSharp/)
 [![NuGet](https://img.shields.io/nuget/v/FixedMathSharp.svg)](https://www.nuget.org/packages/FixedMathSharp)
 [![NuGet Downloads](https://img.shields.io/nuget/dt/FixedMathSharp.svg)](https://www.nuget.org/packages/FixedMathSharp)
 [![License](https://img.shields.io/github/license/mrdav30/FixedMathSharp.svg)](https://github.com/mrdav30/FixedMathSharp/blob/main/LICENSE)

src/FixedMathSharp/.gitignore

@@ -1,2 +1,4 @@
 bin/
 obj/
+
+FixedMathSharp.csproj.user

tests/FixedMathSharp.Tests/.gitignore

@@ -1,2 +1,3 @@
 bin/
 obj/
+TestResults/

tests/FixedMathSharp.Tests/Fixed4x4.Tests.cs

@@ -265,6 +265,19 @@ public void FixedMatrix4x4_TRS_CreatesCorrectTransformationMatrix()
             $"Expected {rotation} but got {decomposedRotation}");
     }
 
+    [Fact]
+    public void FixedMatrix4x4_TranslateRotateScale_MatchesExplicitMultiplicationOrder()
+    {
+        var translation = new Vector3d(3, -2, 5);
+        var rotation = FixedQuaternion.FromEulerAnglesInDegrees((Fixed64)30, (Fixed64)45, (Fixed64)60);
+        var scale = new Vector3d(2, 3, 4);
+
+        var expected = Fixed4x4.CreateTranslation(translation) * Fixed4x4.CreateRotation(rotation) * Fixed4x4.CreateScale(scale);
+        var result = Fixed4x4.TranslateRotateScale(translation, rotation, scale);
+
+        Assert.Equal(expected, result);
+    }
+
     [Fact]
     public void FixedMatrix4x4_Equality_WorksCorrectly()
     {
@@ -310,6 +323,19 @@ public void FixedMatrix4x4_SetGlobalScale_WorksWithRotation()
         Assert.Equal(globalScale, extractedScale);
     }
 
+    [Fact]
+    public void FixedMatrix4x4_SetScale_UpdatesDiagonalComponents()
+    {
+        var matrix = Fixed4x4.CreateTranslation(new Vector3d(5, 6, 7));
+
+        var updated = Fixed4x4.SetScale(matrix, new Vector3d(2, 3, 4));
+
+        Assert.Equal(new Fixed64(2), updated.m00);
+        Assert.Equal(new Fixed64(3), updated.m11);
+        Assert.Equal(new Fixed64(4), updated.m22);
+        Assert.Equal(new Vector3d(5, 6, 7), updated.Translation);
+    }
+
     [Fact]
     public void FixedMatrix4x4_SetRotation_PreservesTranslationAndScale()
     {
@@ -340,6 +366,28 @@ public void FixedMatrix4x4_SetTranslationAndRotationExtensions_UpdateMatrixInPla
         Assert.True(matrix.Rotation.FuzzyEqual(rotation, new Fixed64(0.0001)));
     }
 
+    [Fact]
+    public void FixedMatrix4x4_ExtractRotation_HandlesZeroScaleWithoutThrowing()
+    {
+        var matrix = Fixed4x4.CreateScale(Vector3d.Zero);
+
+        var exception = Record.Exception(() => Fixed4x4.ExtractRotation(matrix));
+
+        Assert.Null(exception);
+    }
+
+    [Fact]
+    public void FixedMatrix4x4_Decompose_ZeroScaleMatrix_ReplacesZeroScaleToAvoidDivisionByZero()
+    {
+        var matrix = Fixed4x4.CreateScale(Vector3d.Zero);
+
+        Assert.True(Fixed4x4.Decompose(matrix, out var scale, out var rotation, out var translation));
+
+        Assert.Equal(Vector3d.One, scale);
+        Assert.Equal(Vector3d.Zero, translation);
+        Assert.Equal(rotation, rotation);
+    }
+
     [Fact]
     public void FixedMatrix4x4_NormalizeRotationMatrixExtension_NormalizesAxesInPlace()
     {
@@ -398,6 +446,15 @@ public void FixedMatrix4x4_Invert_SingularNonAffineMatrix_ReturnsFalse()
         Assert.Equal(Fixed4x4.Identity, inverted);
     }
 
+    [Fact]
+    public void FixedMatrix4x4_Invert_SingularAffineMatrix_ReturnsFalse()
+    {
+        var matrix = Fixed4x4.CreateScale(new Vector3d(0, 1, 1));
+
+        Assert.False(Fixed4x4.Invert(matrix, out var inverted));
+        Assert.Equal(Fixed4x4.Identity, inverted);
+    }
+
     [Fact]
     public void FixedMatrix4x4_TransformPoint_NonAffineMatrix_UsesPerspectiveDivision()
     {
@@ -540,6 +597,12 @@ public void FixedMatrix4x4_OperatorsAndHashCode_WorkCorrectly()
         Assert.NotEqual(hash, changedM13.GetHashCode());
     }
 
+    [Fact]
+    public void FixedMatrix4x4_EqualsObject_ReturnsFalseForDifferentType()
+    {
+        Assert.False(Fixed4x4.Identity.Equals("not-a-matrix"));
+    }
+
     [Fact]
     public void TransformPoint_WorldToLocal_ReturnsCorrectResult()
     {

tests/FixedMathSharp.Tests/FixedMath.Tests.cs

@@ -46,6 +46,14 @@ public void Clamp01_ValueInRange_ReturnsValue()
         Assert.Equal(new Fixed64(0.5f), result);
     }
 
+    [Fact]
+    public void ClampOne_ClampsToNegativeOneOneRange()
+    {
+        Assert.Equal(-Fixed64.One, FixedMath.ClampOne(new Fixed64(-2)));
+        Assert.Equal(new Fixed64(0.5), FixedMath.ClampOne(new Fixed64(0.5)));
+        Assert.Equal(Fixed64.One, FixedMath.ClampOne(new Fixed64(2)));
+    }
+
     #endregion
 
     #region Test: FastAbs Method
@@ -64,6 +72,12 @@ public void FastAbs_NegativeValue_ReturnsPositiveValue()
         Assert.Equal(new Fixed64(10), result);
     }
 
+    [Fact]
+    public void FastAbs_MinValue_ReturnsMaxValue()
+    {
+        Assert.Equal(Fixed64.MAX_VALUE, FixedMath.Abs(Fixed64.MIN_VALUE));
+    }
+
     #endregion
 
     #region Test: Ceiling Method
@@ -158,6 +172,13 @@ public void Round_ToEven_NegativeNumber_RoundsToNearestEven()
         Assert.Equal(new Fixed64(-2), result);
     }
 
+    [Fact]
+    public void Round_AwayFromZero_NegativeHalf_RoundsDown()
+    {
+        var result = FixedMath.Round(new Fixed64(-2.5), MidpointRounding.AwayFromZero);
+        Assert.Equal(new Fixed64(-3), result);
+    }
+
     #endregion
 
     #region Test: Round Method (With Decimal Places)
@@ -183,6 +204,13 @@ public void Round_WithDecimalPlaces_RoundsToZeroDecimalPlaces_AwayFromZero()
         Assert.Equal(new Fixed64(3), result);
     }
 
+    [Fact]
+    public void Round_WithDecimalPlaces_ThrowsWhenPrecisionIsOutOfRange()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => FixedMath.RoundToPrecision(new Fixed64(1.23), -1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => FixedMath.RoundToPrecision(new Fixed64(1.23), FixedMath.Pow10Lookup.Length));
+    }
+
     #endregion
 
     #region Test: FastAdd Method
@@ -377,6 +405,14 @@ public void Clamp_ValueAboveMax_ReturnsMax()
         Assert.Equal(new Fixed64(5), result);
     }
 
+    [Fact]
+    public void Clamp_GenericComparable_ClampsAtBothEndsAndPassesThrough()
+    {
+        Assert.Equal(5, FixedMath.Clamp(9, 1, 5));
+        Assert.Equal(1, FixedMath.Clamp(-3, 1, 5));
+        Assert.Equal(3, FixedMath.Clamp(3, 1, 5));
+    }
+
     #endregion
 
     #region Test: MoveTowards Method
@@ -402,6 +438,13 @@ public void MoveTowards_ValueOvershoot_ReturnsTarget()
         Assert.Equal(new Fixed64(5), result);  // It overshoots, so it should return 5
     }
 
+    [Fact]
+    public void MoveTowards_ValueMovesDownWithOvershoot_ReturnsTarget()
+    {
+        var result = FixedMath.MoveTowards(new Fixed64(5), new Fixed64(3), new Fixed64(3));
+        Assert.Equal(new Fixed64(3), result);
+    }
+
     #endregion
 
     #region Test: FastMod Method (Edge Case)
@@ -462,4 +505,4 @@ public void AddOverflowHelper_NegativeOverflow_SetsOverflowFlag()
     }
 
     #endregion
-}
+}