diff --git a/TUnit.Assertions.Tests/NumericToleranceAssertionTests.cs b/TUnit.Assertions.Tests/NumericToleranceAssertionTests.cs
new file mode 100644
index 0000000000..fdac31cc5d
--- /dev/null
+++ b/TUnit.Assertions.Tests/NumericToleranceAssertionTests.cs
@@ -0,0 +1,291 @@
+using TUnit.Assertions.Extensions;
+
+namespace TUnit.Assertions.Tests;
+
+public class NumericToleranceAssertionTests
+{
+    // ==========================================
+    // IsCloseTo tests - double
+    // ==========================================
+
+    [Test]
+    public async Task Double_IsCloseTo_Within_Tolerance_Passes()
+    {
+        double value = 10.5;
+        await Assert.That(value).IsCloseTo(10.0, 0.5);
+    }
+
+    [Test]
+    public async Task Double_IsCloseTo_Exact_Match_Passes()
+    {
+        double value = 3.14;
+        await Assert.That(value).IsCloseTo(3.14, 0.0);
+    }
+
+    [Test]
+    public async Task Double_IsCloseTo_Outside_Tolerance_Fails()
+    {
+        double value = 10.0;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsCloseTo(12.0, 1.0));
+    }
+
+    [Test]
+    public async Task Double_IsCloseTo_NaN_Both_Passes()
+    {
+        await Assert.That(double.NaN).IsCloseTo(double.NaN, 0.1);
+    }
+
+    [Test]
+    public async Task Double_IsCloseTo_NaN_Actual_Fails()
+    {
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(double.NaN).IsCloseTo(1.0, 0.1));
+    }
+
+    [Test]
+    public async Task Double_IsCloseTo_Negative_Values_Passes()
+    {
+        double value = -5.1;
+        await Assert.That(value).IsCloseTo(-5.0, 0.2);
+    }
+
+    // ==========================================
+    // IsCloseTo tests - float
+    // ==========================================
+
+    [Test]
+    public async Task Float_IsCloseTo_Within_Tolerance_Passes()
+    {
+        float value = 10.5f;
+        await Assert.That(value).IsCloseTo(10.0f, 0.5f);
+    }
+
+    [Test]
+    public async Task Float_IsCloseTo_Outside_Tolerance_Fails()
+    {
+        float value = 10.0f;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsCloseTo(12.0f, 1.0f));
+    }
+
+    [Test]
+    public async Task Float_IsCloseTo_NaN_Both_Passes()
+    {
+        await Assert.That(float.NaN).IsCloseTo(float.NaN, 0.1f);
+    }
+
+    // ==========================================
+    // IsCloseTo tests - int
+    // ==========================================
+
+    [Test]
+    public async Task Int_IsCloseTo_Within_Tolerance_Passes()
+    {
+        int value = 105;
+        await Assert.That(value).IsCloseTo(100, 5);
+    }
+
+    [Test]
+    public async Task Int_IsCloseTo_Exact_Match_Passes()
+    {
+        int value = 42;
+        await Assert.That(value).IsCloseTo(42, 0);
+    }
+
+    [Test]
+    public async Task Int_IsCloseTo_Outside_Tolerance_Fails()
+    {
+        int value = 100;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsCloseTo(110, 5));
+    }
+
+    // ==========================================
+    // IsCloseTo tests - long
+    // ==========================================
+
+    [Test]
+    public async Task Long_IsCloseTo_Within_Tolerance_Passes()
+    {
+        long value = 1000000005L;
+        await Assert.That(value).IsCloseTo(1000000000L, 10L);
+    }
+
+    [Test]
+    public async Task Long_IsCloseTo_Outside_Tolerance_Fails()
+    {
+        long value = 100L;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsCloseTo(200L, 50L));
+    }
+
+    // ==========================================
+    // IsCloseTo tests - decimal
+    // ==========================================
+
+    [Test]
+    public async Task Decimal_IsCloseTo_Within_Tolerance_Passes()
+    {
+        decimal value = 10.05m;
+        await Assert.That(value).IsCloseTo(10.0m, 0.1m);
+    }
+
+    [Test]
+    public async Task Decimal_IsCloseTo_Outside_Tolerance_Fails()
+    {
+        decimal value = 10.0m;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsCloseTo(12.0m, 1.0m));
+    }
+
+    // ==========================================
+    // IsWithinPercentOf tests - double
+    // ==========================================
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_Passes()
+    {
+        double value = 105.0;
+        await Assert.That(value).IsWithinPercentOf(100.0, 10.0);
+    }
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_Exact_Match_Passes()
+    {
+        double value = 100.0;
+        await Assert.That(value).IsWithinPercentOf(100.0, 0.0);
+    }
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_At_Boundary_Passes()
+    {
+        double value = 110.0;
+        await Assert.That(value).IsWithinPercentOf(100.0, 10.0);
+    }
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_Outside_Fails()
+    {
+        double value = 120.0;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(100.0, 10.0));
+    }
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_Negative_Expected_Passes()
+    {
+        double value = -95.0;
+        await Assert.That(value).IsWithinPercentOf(-100.0, 10.0);
+    }
+
+    [Test]
+    public async Task Double_IsWithinPercentOf_NaN_Both_Passes()
+    {
+        await Assert.That(double.NaN).IsWithinPercentOf(double.NaN, 10.0);
+    }
+
+    // ==========================================
+    // IsWithinPercentOf tests - float
+    // ==========================================
+
+    [Test]
+    public async Task Float_IsWithinPercentOf_Passes()
+    {
+        float value = 105.0f;
+        await Assert.That(value).IsWithinPercentOf(100.0f, 10.0f);
+    }
+
+    [Test]
+    public async Task Float_IsWithinPercentOf_Outside_Fails()
+    {
+        float value = 120.0f;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(100.0f, 10.0f));
+    }
+
+    // ==========================================
+    // IsWithinPercentOf tests - int
+    // ==========================================
+
+    [Test]
+    public async Task Int_IsWithinPercentOf_Passes()
+    {
+        int value = 105;
+        await Assert.That(value).IsWithinPercentOf(100, 10.0);
+    }
+
+    [Test]
+    public async Task Int_IsWithinPercentOf_Outside_Fails()
+    {
+        int value = 120;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(100, 10.0));
+    }
+
+    // ==========================================
+    // IsWithinPercentOf tests - long
+    // ==========================================
+
+    [Test]
+    public async Task Long_IsWithinPercentOf_Passes()
+    {
+        long value = 1050L;
+        await Assert.That(value).IsWithinPercentOf(1000L, 10.0);
+    }
+
+    [Test]
+    public async Task Long_IsWithinPercentOf_Outside_Fails()
+    {
+        long value = 1200L;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(1000L, 10.0));
+    }
+
+    // ==========================================
+    // IsWithinPercentOf tests - decimal
+    // ==========================================
+
+    [Test]
+    public async Task Decimal_IsWithinPercentOf_Passes()
+    {
+        decimal value = 105.0m;
+        await Assert.That(value).IsWithinPercentOf(100.0m, 10.0m);
+    }
+
+    [Test]
+    public async Task Decimal_IsWithinPercentOf_Outside_Fails()
+    {
+        decimal value = 120.0m;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(100.0m, 10.0m));
+    }
+
+    // ==========================================
+    // Edge cases
+    // ==========================================
+
+    [Test]
+    public async Task Double_IsCloseTo_Zero_Expected_Passes()
+    {
+        double value = 0.001;
+        await Assert.That(value).IsCloseTo(0.0, 0.01);
+    }
+
+    [Test]
+    public async Task Int_IsWithinPercentOf_Zero_Expected_Fails()
+    {
+        // 10% of 0 is 0, so only exact match passes
+        int value = 1;
+        await Assert.ThrowsAsync<AssertionException>(
+            async () => await Assert.That(value).IsWithinPercentOf(0, 10.0));
+    }
+
+    [Test]
+    public async Task Int_IsWithinPercentOf_Zero_Expected_Zero_Actual_Passes()
+    {
+        // 0 is within any percent of 0
+        int value = 0;
+        await Assert.That(value).IsWithinPercentOf(0, 10.0);
+    }
+}
diff --git a/TUnit.Assertions/Conditions/NumericIsCloseToAssertion.cs b/TUnit.Assertions/Conditions/NumericIsCloseToAssertion.cs
new file mode 100644
index 0000000000..3030f136aa
--- /dev/null
+++ b/TUnit.Assertions/Conditions/NumericIsCloseToAssertion.cs
@@ -0,0 +1,268 @@
+using TUnit.Assertions.Attributes;
+using TUnit.Assertions.Core;
+
+namespace TUnit.Assertions.Conditions;
+
+/// <summary>
+/// Asserts that a double value is close to an expected value within an absolute tolerance.
+/// |actual - expected| &lt;= tolerance
+/// </summary>
+[AssertionExtension("IsCloseTo", OverloadResolutionPriority = 2)]
+public class DoubleIsCloseToAssertion : Assertion<double>
+{
+    private readonly double _expected;
+    private readonly double _tolerance;
+
+    public DoubleIsCloseToAssertion(
+        AssertionContext<double> context,
+        double expected,
+        double tolerance)
+        : base(context)
+    {
+        _expected = expected;
+        _tolerance = tolerance;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<double> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        // Handle NaN comparisons
+        if (double.IsNaN(value) && double.IsNaN(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (double.IsNaN(value) || double.IsNaN(_expected))
+        {
+            return Task.FromResult(AssertionResult.Failed($"found {value}"));
+        }
+
+        // Handle infinity
+        if (double.IsPositiveInfinity(value) && double.IsPositiveInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (double.IsNegativeInfinity(value) && double.IsNegativeInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var diff = Math.Abs(value - _expected);
+
+        if (diff <= _tolerance)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"found {value}, which differs by {diff}"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be close to {_expected} within tolerance {_tolerance}";
+}
+
+/// <summary>
+/// Asserts that a float value is close to an expected value within an absolute tolerance.
+/// |actual - expected| &lt;= tolerance
+/// </summary>
+[AssertionExtension("IsCloseTo", OverloadResolutionPriority = 2)]
+public class FloatIsCloseToAssertion : Assertion<float>
+{
+    private readonly float _expected;
+    private readonly float _tolerance;
+
+    public FloatIsCloseToAssertion(
+        AssertionContext<float> context,
+        float expected,
+        float tolerance)
+        : base(context)
+    {
+        _expected = expected;
+        _tolerance = tolerance;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<float> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        // Handle NaN comparisons
+        if (float.IsNaN(value) && float.IsNaN(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (float.IsNaN(value) || float.IsNaN(_expected))
+        {
+            return Task.FromResult(AssertionResult.Failed($"found {value}"));
+        }
+
+        // Handle infinity
+        if (float.IsPositiveInfinity(value) && float.IsPositiveInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (float.IsNegativeInfinity(value) && float.IsNegativeInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var diff = Math.Abs(value - _expected);
+
+        if (diff <= _tolerance)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"found {value}, which differs by {diff}"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be close to {_expected} within tolerance {_tolerance}";
+}
+
+/// <summary>
+/// Asserts that an int value is close to an expected value within an absolute tolerance.
+/// |actual - expected| &lt;= tolerance
+/// </summary>
+[AssertionExtension("IsCloseTo", OverloadResolutionPriority = 2)]
+public class IntIsCloseToAssertion : Assertion<int>
+{
+    private readonly int _expected;
+    private readonly int _tolerance;
+
+    public IntIsCloseToAssertion(
+        AssertionContext<int> context,
+        int expected,
+        int tolerance)
+        : base(context)
+    {
+        _expected = expected;
+        _tolerance = tolerance;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<int> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs((long)value - _expected);
+
+        if (diff <= _tolerance)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"found {value}, which differs by {diff}"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be close to {_expected} within tolerance {_tolerance}";
+}
+
+/// <summary>
+/// Asserts that a long value is close to an expected value within an absolute tolerance.
+/// |actual - expected| &lt;= tolerance
+/// </summary>
+[AssertionExtension("IsCloseTo", OverloadResolutionPriority = 2)]
+public class LongIsCloseToAssertion : Assertion<long>
+{
+    private readonly long _expected;
+    private readonly long _tolerance;
+
+    public LongIsCloseToAssertion(
+        AssertionContext<long> context,
+        long expected,
+        long tolerance)
+        : base(context)
+    {
+        _expected = expected;
+        _tolerance = tolerance;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<long> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs((double)value - _expected);
+
+        if (diff <= (double)_tolerance)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"found {value}, which differs by {diff}"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be close to {_expected} within tolerance {_tolerance}";
+}
+
+/// <summary>
+/// Asserts that a decimal value is close to an expected value within an absolute tolerance.
+/// |actual - expected| &lt;= tolerance
+/// </summary>
+[AssertionExtension("IsCloseTo", OverloadResolutionPriority = 2)]
+public class DecimalIsCloseToAssertion : Assertion<decimal>
+{
+    private readonly decimal _expected;
+    private readonly decimal _tolerance;
+
+    public DecimalIsCloseToAssertion(
+        AssertionContext<decimal> context,
+        decimal expected,
+        decimal tolerance)
+        : base(context)
+    {
+        _expected = expected;
+        _tolerance = tolerance;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<decimal> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs(value - _expected);
+
+        if (diff <= _tolerance)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed($"found {value}, which differs by {diff}"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be close to {_expected} within tolerance {_tolerance}";
+}
diff --git a/TUnit.Assertions/Conditions/NumericIsWithinPercentOfAssertion.cs b/TUnit.Assertions/Conditions/NumericIsWithinPercentOfAssertion.cs
new file mode 100644
index 0000000000..03b6a51abe
--- /dev/null
+++ b/TUnit.Assertions/Conditions/NumericIsWithinPercentOfAssertion.cs
@@ -0,0 +1,282 @@
+using TUnit.Assertions.Attributes;
+using TUnit.Assertions.Core;
+
+namespace TUnit.Assertions.Conditions;
+
+/// <summary>
+/// Asserts that a double value is within a given percentage of an expected value.
+/// |actual - expected| &lt;= |expected * percent / 100|
+/// </summary>
+[AssertionExtension("IsWithinPercentOf", OverloadResolutionPriority = 2)]
+public class DoubleIsWithinPercentOfAssertion : Assertion<double>
+{
+    private readonly double _expected;
+    private readonly double _percent;
+
+    public DoubleIsWithinPercentOfAssertion(
+        AssertionContext<double> context,
+        double expected,
+        double percent)
+        : base(context)
+    {
+        _expected = expected;
+        _percent = percent;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<double> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        // Handle NaN comparisons
+        if (double.IsNaN(value) && double.IsNaN(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (double.IsNaN(value) || double.IsNaN(_expected))
+        {
+            return Task.FromResult(AssertionResult.Failed($"found {value}"));
+        }
+
+        // Handle infinity
+        if (double.IsPositiveInfinity(value) && double.IsPositiveInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (double.IsNegativeInfinity(value) && double.IsNegativeInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var diff = Math.Abs(value - _expected);
+        var allowedDelta = Math.Abs(_expected * _percent / 100.0);
+
+        if (diff <= allowedDelta)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed(
+            $"found {value}, which differs by {diff} ({(diff / Math.Abs(_expected)) * 100:F2}% of expected)"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be within {_percent}% of {_expected}";
+}
+
+/// <summary>
+/// Asserts that a float value is within a given percentage of an expected value.
+/// |actual - expected| &lt;= |expected * percent / 100|
+/// </summary>
+[AssertionExtension("IsWithinPercentOf", OverloadResolutionPriority = 2)]
+public class FloatIsWithinPercentOfAssertion : Assertion<float>
+{
+    private readonly float _expected;
+    private readonly float _percent;
+
+    public FloatIsWithinPercentOfAssertion(
+        AssertionContext<float> context,
+        float expected,
+        float percent)
+        : base(context)
+    {
+        _expected = expected;
+        _percent = percent;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<float> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        // Handle NaN comparisons
+        if (float.IsNaN(value) && float.IsNaN(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (float.IsNaN(value) || float.IsNaN(_expected))
+        {
+            return Task.FromResult(AssertionResult.Failed($"found {value}"));
+        }
+
+        // Handle infinity
+        if (float.IsPositiveInfinity(value) && float.IsPositiveInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        if (float.IsNegativeInfinity(value) && float.IsNegativeInfinity(_expected))
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var diff = Math.Abs(value - _expected);
+        var allowedDelta = Math.Abs(_expected * _percent / 100.0f);
+
+        if (diff <= allowedDelta)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed(
+            $"found {value}, which differs by {diff} ({(diff / Math.Abs(_expected)) * 100:F2}% of expected)"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be within {_percent}% of {_expected}";
+}
+
+/// <summary>
+/// Asserts that an int value is within a given percentage of an expected value.
+/// |actual - expected| &lt;= |expected * percent / 100|
+/// </summary>
+[AssertionExtension("IsWithinPercentOf", OverloadResolutionPriority = 2)]
+public class IntIsWithinPercentOfAssertion : Assertion<int>
+{
+    private readonly int _expected;
+    private readonly double _percent;
+
+    public IntIsWithinPercentOfAssertion(
+        AssertionContext<int> context,
+        int expected,
+        double percent)
+        : base(context)
+    {
+        _expected = expected;
+        _percent = percent;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<int> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs((double)value - _expected);
+        var allowedDelta = Math.Abs(_expected * _percent / 100.0);
+
+        if (diff <= allowedDelta)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var actualPercent = _expected != 0 ? (diff / Math.Abs(_expected)) * 100 : double.PositiveInfinity;
+        return Task.FromResult(AssertionResult.Failed(
+            $"found {value}, which differs by {(long)diff} ({actualPercent:F2}% of expected)"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be within {_percent}% of {_expected}";
+}
+
+/// <summary>
+/// Asserts that a long value is within a given percentage of an expected value.
+/// |actual - expected| &lt;= |expected * percent / 100|
+/// </summary>
+[AssertionExtension("IsWithinPercentOf", OverloadResolutionPriority = 2)]
+public class LongIsWithinPercentOfAssertion : Assertion<long>
+{
+    private readonly long _expected;
+    private readonly double _percent;
+
+    public LongIsWithinPercentOfAssertion(
+        AssertionContext<long> context,
+        long expected,
+        double percent)
+        : base(context)
+    {
+        _expected = expected;
+        _percent = percent;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<long> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs((double)value - _expected);
+        var allowedDelta = Math.Abs(_expected * _percent / 100.0);
+
+        if (diff <= allowedDelta)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var actualPercent = _expected != 0 ? (diff / Math.Abs(_expected)) * 100 : double.PositiveInfinity;
+        return Task.FromResult(AssertionResult.Failed(
+            $"found {value}, which differs by {(long)diff} ({actualPercent:F2}% of expected)"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be within {_percent}% of {_expected}";
+}
+
+/// <summary>
+/// Asserts that a decimal value is within a given percentage of an expected value.
+/// |actual - expected| &lt;= |expected * percent / 100|
+/// </summary>
+[AssertionExtension("IsWithinPercentOf", OverloadResolutionPriority = 2)]
+public class DecimalIsWithinPercentOfAssertion : Assertion<decimal>
+{
+    private readonly decimal _expected;
+    private readonly decimal _percent;
+
+    public DecimalIsWithinPercentOfAssertion(
+        AssertionContext<decimal> context,
+        decimal expected,
+        decimal percent)
+        : base(context)
+    {
+        _expected = expected;
+        _percent = percent;
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<decimal> metadata)
+    {
+        var value = metadata.Value;
+        var exception = metadata.Exception;
+
+        if (exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {exception.GetType().Name}"));
+        }
+
+        var diff = Math.Abs(value - _expected);
+        var allowedDelta = Math.Abs(_expected * _percent / 100m);
+
+        if (diff <= allowedDelta)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        var actualPercent = _expected != 0 ? (diff / Math.Abs(_expected)) * 100m : -1m;
+        var percentDisplay = actualPercent >= 0 ? $"{actualPercent:F2}%" : "Infinity%";
+        return Task.FromResult(AssertionResult.Failed(
+            $"found {value}, which differs by {diff} ({percentDisplay} of expected)"));
+    }
+
+    protected override string GetExpectation() =>
+        $"to be within {_percent}% of {_expected}";
+}
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
index c077811935..5b889b7881 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt
@@ -997,6 +997,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(decimal actual, decimal expected, decimal tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DecimalIsCloseToAssertion : .<decimal>
+    {
+        public DecimalIsCloseToAssertion(.<decimal> context, decimal expected, decimal tolerance) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DecimalIsWithinPercentOfAssertion : .<decimal>
+    {
+        public DecimalIsWithinPercentOfAssertion(.<decimal> context, decimal expected, decimal percent) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class DictionaryAllKeysAssertion<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue>
         where TKey :  notnull
@@ -1112,6 +1126,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(double actual, double expected, double tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DoubleIsCloseToAssertion : .<double>
+    {
+        public DoubleIsCloseToAssertion(.<double> context, double expected, double tolerance) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DoubleIsWithinPercentOfAssertion : .<double>
+    {
+        public DoubleIsWithinPercentOfAssertion(.<double> context, double expected, double percent) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsEqualTo")]
     public class EqualsAssertion<TValue> : .<TValue>
     {
@@ -1224,6 +1252,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(float actual, float expected, float tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class FloatIsCloseToAssertion : .<float>
+    {
+        public FloatIsCloseToAssertion(.<float> context, float expected, float tolerance) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class FloatIsWithinPercentOfAssertion : .<float>
+    {
+        public FloatIsWithinPercentOfAssertion(.<float> context, float expected, float percent) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsGreaterThan")]
     public class GreaterThanAssertion<TValue> : .<TValue>
         where TValue : <TValue>
@@ -1341,6 +1383,20 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class IntIsCloseToAssertion : .<int>
+    {
+        public IntIsCloseToAssertion(.<int> context, int expected, int tolerance) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class IntIsWithinPercentOfAssertion : .<int>
+    {
+        public IntIsWithinPercentOfAssertion(.<int> context, int expected, double percent) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1539,6 +1595,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(long actual, long expected, long tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class LongIsCloseToAssertion : .<long>
+    {
+        public LongIsCloseToAssertion(.<long> context, long expected, long tolerance) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class LongIsWithinPercentOfAssertion : .<long>
+    {
+        public LongIsWithinPercentOfAssertion(.<long> context, long expected, double percent) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class MappedSatisfiesAssertion<TValue, TMapped> : .<TValue>
     {
         public MappedSatisfiesAssertion(.<TValue> context, <TValue?, TMapped> selector, <.<TMapped>, .?> assertions, string selectorDescription) { }
@@ -3376,6 +3446,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<decimal> source, decimal expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DecimalIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<decimal> source, decimal expected, decimal tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class DecimalIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<decimal> source, decimal expected, decimal percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Decimal_IsNotZero_Assertion : .<decimal>
     {
         public Decimal_IsNotZero_Assertion(.<decimal> context) { }
@@ -3501,6 +3581,11 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<double> source, double expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DoubleIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<double> source, double expected, double tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class DoubleIsFiniteWithDoubleAssertion : .<double>
     {
         public DoubleIsFiniteWithDoubleAssertion(.<double> context, bool negated = false) { }
@@ -3543,6 +3628,11 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<double> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class DoubleIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<double> source, double expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Double_IsNotZero_Assertion : .<double>
     {
         public Double_IsNotZero_Assertion(.<double> context) { }
@@ -3808,6 +3898,11 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<float> source, float expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class FloatIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<float> source, float expected, float tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class FloatIsFiniteWithFloatAssertion : .<float>
     {
         public FloatIsFiniteWithFloatAssertion(.<float> context, bool negated = false) { }
@@ -3850,6 +3945,11 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<float> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class FloatIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<float> source, float expected, float percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Float_IsNotZero_Assertion : .<float>
     {
         public Float_IsNotZero_Assertion(.<float> context) { }
@@ -4182,6 +4282,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<int> source, int expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class IntIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<int> source, int expected, int tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class IntIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<int> source, int expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Int_IsEven_Assertion : .<int>
     {
         public Int_IsEven_Assertion(.<int> context) { }
@@ -4454,6 +4564,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<long> source, long expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class LongIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<long> source, long expected, long tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class LongIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<long> source, long expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Long_IsEven_Assertion : .<long>
     {
         public Long_IsEven_Assertion(.<long> context) { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
index 22c60eeb60..ee583b2ced 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet8_0.verified.txt
@@ -980,6 +980,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(decimal actual, decimal expected, decimal tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DecimalIsCloseToAssertion : .<decimal>
+    {
+        public DecimalIsCloseToAssertion(.<decimal> context, decimal expected, decimal tolerance) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DecimalIsWithinPercentOfAssertion : .<decimal>
+    {
+        public DecimalIsWithinPercentOfAssertion(.<decimal> context, decimal expected, decimal percent) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class DictionaryAllKeysAssertion<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue>
         where TKey :  notnull
@@ -1095,6 +1109,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(double actual, double expected, double tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DoubleIsCloseToAssertion : .<double>
+    {
+        public DoubleIsCloseToAssertion(.<double> context, double expected, double tolerance) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DoubleIsWithinPercentOfAssertion : .<double>
+    {
+        public DoubleIsWithinPercentOfAssertion(.<double> context, double expected, double percent) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsEqualTo")]
     public class EqualsAssertion<TValue> : .<TValue>
     {
@@ -1207,6 +1235,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(float actual, float expected, float tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class FloatIsCloseToAssertion : .<float>
+    {
+        public FloatIsCloseToAssertion(.<float> context, float expected, float tolerance) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class FloatIsWithinPercentOfAssertion : .<float>
+    {
+        public FloatIsWithinPercentOfAssertion(.<float> context, float expected, float percent) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsGreaterThan")]
     public class GreaterThanAssertion<TValue> : .<TValue>
         where TValue : <TValue>
@@ -1324,6 +1366,20 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class IntIsCloseToAssertion : .<int>
+    {
+        public IntIsCloseToAssertion(.<int> context, int expected, int tolerance) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class IntIsWithinPercentOfAssertion : .<int>
+    {
+        public IntIsWithinPercentOfAssertion(.<int> context, int expected, double percent) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1522,6 +1578,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(long actual, long expected, long tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class LongIsCloseToAssertion : .<long>
+    {
+        public LongIsCloseToAssertion(.<long> context, long expected, long tolerance) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class LongIsWithinPercentOfAssertion : .<long>
+    {
+        public LongIsWithinPercentOfAssertion(.<long> context, long expected, double percent) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class MappedSatisfiesAssertion<TValue, TMapped> : .<TValue>
     {
         public MappedSatisfiesAssertion(.<TValue> context, <TValue?, TMapped> selector, <.<TMapped>, .?> assertions, string selectorDescription) { }
@@ -3344,6 +3414,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<decimal> source, decimal expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DecimalIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<decimal> source, decimal expected, decimal tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class DecimalIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<decimal> source, decimal expected, decimal percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Decimal_IsNotZero_Assertion : .<decimal>
     {
         public Decimal_IsNotZero_Assertion(.<decimal> context) { }
@@ -3468,6 +3546,10 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<double> source, double expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DoubleIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<double> source, double expected, double tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class DoubleIsFiniteWithDoubleAssertion : .<double>
     {
         public DoubleIsFiniteWithDoubleAssertion(.<double> context, bool negated = false) { }
@@ -3510,6 +3592,10 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<double> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class DoubleIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<double> source, double expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Double_IsNotZero_Assertion : .<double>
     {
         public Double_IsNotZero_Assertion(.<double> context) { }
@@ -3774,6 +3860,10 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<float> source, float expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class FloatIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<float> source, float expected, float tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class FloatIsFiniteWithFloatAssertion : .<float>
     {
         public FloatIsFiniteWithFloatAssertion(.<float> context, bool negated = false) { }
@@ -3816,6 +3906,10 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<float> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class FloatIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<float> source, float expected, float percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Float_IsNotZero_Assertion : .<float>
     {
         public Float_IsNotZero_Assertion(.<float> context) { }
@@ -4147,6 +4241,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<int> source, int expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class IntIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<int> source, int expected, int tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class IntIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<int> source, int expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Int_IsEven_Assertion : .<int>
     {
         public Int_IsEven_Assertion(.<int> context) { }
@@ -4404,6 +4506,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<long> source, long expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class LongIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<long> source, long expected, long tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class LongIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<long> source, long expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Long_IsEven_Assertion : .<long>
     {
         public Long_IsEven_Assertion(.<long> context) { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
index 2444ba3104..5042128ae8 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt
@@ -997,6 +997,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(decimal actual, decimal expected, decimal tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DecimalIsCloseToAssertion : .<decimal>
+    {
+        public DecimalIsCloseToAssertion(.<decimal> context, decimal expected, decimal tolerance) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DecimalIsWithinPercentOfAssertion : .<decimal>
+    {
+        public DecimalIsWithinPercentOfAssertion(.<decimal> context, decimal expected, decimal percent) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class DictionaryAllKeysAssertion<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue>
         where TKey :  notnull
@@ -1112,6 +1126,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(double actual, double expected, double tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DoubleIsCloseToAssertion : .<double>
+    {
+        public DoubleIsCloseToAssertion(.<double> context, double expected, double tolerance) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DoubleIsWithinPercentOfAssertion : .<double>
+    {
+        public DoubleIsWithinPercentOfAssertion(.<double> context, double expected, double percent) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsEqualTo")]
     public class EqualsAssertion<TValue> : .<TValue>
     {
@@ -1224,6 +1252,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(float actual, float expected, float tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class FloatIsCloseToAssertion : .<float>
+    {
+        public FloatIsCloseToAssertion(.<float> context, float expected, float tolerance) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class FloatIsWithinPercentOfAssertion : .<float>
+    {
+        public FloatIsWithinPercentOfAssertion(.<float> context, float expected, float percent) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsGreaterThan")]
     public class GreaterThanAssertion<TValue> : .<TValue>
         where TValue : <TValue>
@@ -1341,6 +1383,20 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class IntIsCloseToAssertion : .<int>
+    {
+        public IntIsCloseToAssertion(.<int> context, int expected, int tolerance) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class IntIsWithinPercentOfAssertion : .<int>
+    {
+        public IntIsWithinPercentOfAssertion(.<int> context, int expected, double percent) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1539,6 +1595,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(long actual, long expected, long tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class LongIsCloseToAssertion : .<long>
+    {
+        public LongIsCloseToAssertion(.<long> context, long expected, long tolerance) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class LongIsWithinPercentOfAssertion : .<long>
+    {
+        public LongIsWithinPercentOfAssertion(.<long> context, long expected, double percent) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class MappedSatisfiesAssertion<TValue, TMapped> : .<TValue>
     {
         public MappedSatisfiesAssertion(.<TValue> context, <TValue?, TMapped> selector, <.<TMapped>, .?> assertions, string selectorDescription) { }
@@ -3376,6 +3446,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<decimal> source, decimal expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DecimalIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<decimal> source, decimal expected, decimal tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class DecimalIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<decimal> source, decimal expected, decimal percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Decimal_IsNotZero_Assertion : .<decimal>
     {
         public Decimal_IsNotZero_Assertion(.<decimal> context) { }
@@ -3501,6 +3581,11 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<double> source, double expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DoubleIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<double> source, double expected, double tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class DoubleIsFiniteWithDoubleAssertion : .<double>
     {
         public DoubleIsFiniteWithDoubleAssertion(.<double> context, bool negated = false) { }
@@ -3543,6 +3628,11 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<double> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class DoubleIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<double> source, double expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Double_IsNotZero_Assertion : .<double>
     {
         public Double_IsNotZero_Assertion(.<double> context) { }
@@ -3808,6 +3898,11 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<float> source, float expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class FloatIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<float> source, float expected, float tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class FloatIsFiniteWithFloatAssertion : .<float>
     {
         public FloatIsFiniteWithFloatAssertion(.<float> context, bool negated = false) { }
@@ -3850,6 +3945,11 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<float> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class FloatIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<float> source, float expected, float percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Float_IsNotZero_Assertion : .<float>
     {
         public Float_IsNotZero_Assertion(.<float> context) { }
@@ -4182,6 +4282,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<int> source, int expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class IntIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<int> source, int expected, int tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class IntIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<int> source, int expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Int_IsEven_Assertion : .<int>
     {
         public Int_IsEven_Assertion(.<int> context) { }
@@ -4454,6 +4564,16 @@ namespace .Extensions
         [.(2)]
         public static . IsEqualTo(this .<long> source, long expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class LongIsCloseToAssertionExtensions
+    {
+        [.(2)]
+        public static . IsCloseTo(this .<long> source, long expected, long tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class LongIsWithinPercentOfAssertionExtensions
+    {
+        [.(2)]
+        public static . IsWithinPercentOf(this .<long> source, long expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Long_IsEven_Assertion : .<long>
     {
         public Long_IsEven_Assertion(.<long> context) { }
diff --git a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
index 3457173c39..99e4030670 100644
--- a/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -835,6 +835,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(decimal actual, decimal expected, decimal tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DecimalIsCloseToAssertion : .<decimal>
+    {
+        public DecimalIsCloseToAssertion(.<decimal> context, decimal expected, decimal tolerance) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DecimalIsWithinPercentOfAssertion : .<decimal>
+    {
+        public DecimalIsWithinPercentOfAssertion(.<decimal> context, decimal expected, decimal percent) { }
+        protected override .<.> CheckAsync(.<decimal> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class DictionaryAllKeysAssertion<TDictionary, TKey, TValue> : .<TDictionary, TKey, TValue>
         where TDictionary : .<TKey, TValue>
         where TKey :  notnull
@@ -944,6 +958,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(double actual, double expected, double tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class DoubleIsCloseToAssertion : .<double>
+    {
+        public DoubleIsCloseToAssertion(.<double> context, double expected, double tolerance) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class DoubleIsWithinPercentOfAssertion : .<double>
+    {
+        public DoubleIsWithinPercentOfAssertion(.<double> context, double expected, double percent) { }
+        protected override .<.> CheckAsync(.<double> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsEqualTo")]
     public class EqualsAssertion<TValue> : .<TValue>
     {
@@ -1056,6 +1084,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(float actual, float expected, float tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class FloatIsCloseToAssertion : .<float>
+    {
+        public FloatIsCloseToAssertion(.<float> context, float expected, float tolerance) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class FloatIsWithinPercentOfAssertion : .<float>
+    {
+        public FloatIsWithinPercentOfAssertion(.<float> context, float expected, float percent) { }
+        protected override .<.> CheckAsync(.<float> metadata) { }
+        protected override string GetExpectation() { }
+    }
     [.("IsGreaterThan")]
     public class GreaterThanAssertion<TValue> : .<TValue>
         where TValue : <TValue>
@@ -1170,6 +1212,20 @@ namespace .Conditions
         protected override string GetExpectation() { }
         public . Within(int tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class IntIsCloseToAssertion : .<int>
+    {
+        public IntIsCloseToAssertion(.<int> context, int expected, int tolerance) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class IntIsWithinPercentOfAssertion : .<int>
+    {
+        public IntIsWithinPercentOfAssertion(.<int> context, int expected, double percent) { }
+        protected override .<.> CheckAsync(.<int> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class IsAssignableToAssertion<TTarget, TValue> : .<TValue>
     {
         public IsAssignableToAssertion(.<TValue> context) { }
@@ -1366,6 +1422,20 @@ namespace .Conditions
         protected override bool HasToleranceValue() { }
         protected override bool IsWithinTolerance(long actual, long expected, long tolerance) { }
     }
+    [.("IsCloseTo", OverloadResolutionPriority=2)]
+    public class LongIsCloseToAssertion : .<long>
+    {
+        public LongIsCloseToAssertion(.<long> context, long expected, long tolerance) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
+    [.("IsWithinPercentOf", OverloadResolutionPriority=2)]
+    public class LongIsWithinPercentOfAssertion : .<long>
+    {
+        public LongIsWithinPercentOfAssertion(.<long> context, long expected, double percent) { }
+        protected override .<.> CheckAsync(.<long> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public class MappedSatisfiesAssertion<TValue, TMapped> : .<TValue>
     {
         public MappedSatisfiesAssertion(.<TValue> context, <TValue?, TMapped> selector, <.<TMapped>, .?> assertions, string selectorDescription) { }
@@ -3003,6 +3073,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<decimal> source, decimal expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DecimalIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<decimal> source, decimal expected, decimal tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class DecimalIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<decimal> source, decimal expected, decimal percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Decimal_IsNotZero_Assertion : .<decimal>
     {
         public Decimal_IsNotZero_Assertion(.<decimal> context) { }
@@ -3121,6 +3199,10 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<double> source, double expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class DoubleIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<double> source, double expected, double tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class DoubleIsInfinityWithDoubleAssertion : .<double>
     {
         public DoubleIsInfinityWithDoubleAssertion(.<double> context, bool negated = false) { }
@@ -3145,6 +3227,10 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<double> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class DoubleIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<double> source, double expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Double_IsNotZero_Assertion : .<double>
     {
         public Double_IsNotZero_Assertion(.<double> context) { }
@@ -3405,6 +3491,10 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<float> source, float expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class FloatIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<float> source, float expected, float tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
     public class FloatIsInfinityWithFloatAssertion : .<float>
     {
         public FloatIsInfinityWithFloatAssertion(.<float> context, bool negated = false) { }
@@ -3429,6 +3519,10 @@ namespace .Extensions
         protected override .<.> CheckAsync(.<float> metadata) { }
         protected override string GetExpectation() { }
     }
+    public static class FloatIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<float> source, float expected, float percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Float_IsNotZero_Assertion : .<float>
     {
         public Float_IsNotZero_Assertion(.<float> context) { }
@@ -3743,6 +3837,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<int> source, int expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class IntIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<int> source, int expected, int tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class IntIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<int> source, int expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Int_IsEven_Assertion : .<int>
     {
         public Int_IsEven_Assertion(.<int> context) { }
@@ -3978,6 +4080,14 @@ namespace .Extensions
     {
         public static . IsEqualTo(this .<long> source, long expected, [.("expected")] string? expectedExpression = null) { }
     }
+    public static class LongIsCloseToAssertionExtensions
+    {
+        public static . IsCloseTo(this .<long> source, long expected, long tolerance, [.("expected")] string? expectedExpression = null, [.("tolerance")] string? toleranceExpression = null) { }
+    }
+    public static class LongIsWithinPercentOfAssertionExtensions
+    {
+        public static . IsWithinPercentOf(this .<long> source, long expected, double percent, [.("expected")] string? expectedExpression = null, [.("percent")] string? percentExpression = null) { }
+    }
     public sealed class Long_IsEven_Assertion : .<long>
     {
         public Long_IsEven_Assertion(.<long> context) { }