diff --git a/src/MrKWatkins.Assertions.Tests/AsyncActionAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/AsyncActionAssertionsTests.cs
new file mode 100644
index 0000000..6ddd643
--- /dev/null
+++ b/src/MrKWatkins.Assertions.Tests/AsyncActionAssertionsTests.cs
@@ -0,0 +1,149 @@
+namespace MrKWatkins.Assertions.Tests;
+
+public sealed class AsyncActionAssertionsTests
+{
+    [Test]
+    public async Task ThrowAsync()
+    {
+        Func<Task> doesNotThrow = () => Task.CompletedTask;
+        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+
+        var exception = new InvalidOperationException("Test");
+        Func<Task> throws = () => throw exception;
+        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+
+        Func<Task> throwsWrongException = () => throw new NotSupportedException("Wrong");
+        Func<Task> throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
+
+        await Assert.That(() => throws.Should().ThrowAsync<InvalidOperationException>()).ThrowsNothing();
+        await Assert.That(() => throwsAsync.Should().ThrowAsync<InvalidOperationException>()).ThrowsNothing();
+
+        await Assert.That(() => doesNotThrow.Should().ThrowAsync<InvalidOperationException>())
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException.");
+        await Assert.That(() => doesNotThrowAsync.Should().ThrowAsync<InvalidOperationException>())
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException.");
+
+        await Assert.That(() => throwsWrongException.Should().ThrowAsync<InvalidOperationException>())
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException but threw a NotSupportedException with message \"Wrong\".");
+        await Assert.That(() => throwsWrongExceptionAsync.Should().ThrowAsync<InvalidOperationException>())
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException but threw a NotSupportedException with message \"Wrong\".");
+    }
+
+    [Test]
+    public async Task ThrowAsync_Chain()
+    {
+        var exception = new InvalidOperationException("Test");
+        Func<Task> throws = () => throw exception;
+        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+
+        var chain = await throws.Should().ThrowAsync<InvalidOperationException>().ConfigureAwait(false);
+        await Assert.That(chain.Exception).IsSameReferenceAs(exception);
+        await Assert.That(chain.That).IsSameReferenceAs(exception);
+
+        chain = await throwsAsync.Should().ThrowAsync<InvalidOperationException>().ConfigureAwait(false);
+        await Assert.That(chain.Exception).IsSameReferenceAs(exception);
+        await Assert.That(chain.That).IsSameReferenceAs(exception);
+    }
+
+    [Test]
+    public async Task ThrowAsync_String()
+    {
+        Func<Task> doesNotThrow = () => Task.CompletedTask;
+        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+
+        var exception = new InvalidOperationException("Test");
+        Func<Task> throws = () => throw exception;
+        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+
+        Func<Task> throwsWrongException = () => throw new NotSupportedException("Wrong");
+        Func<Task> throwsWrongExceptionAsync = async () => { await Task.Yield(); throw new NotSupportedException("Wrong"); };
+
+        await Assert.That(() => throws.Should().ThrowAsync<InvalidOperationException>("Test")).ThrowsNothing();
+        await Assert.That(() => throwsAsync.Should().ThrowAsync<InvalidOperationException>("Test")).ThrowsNothing();
+
+        await Assert.That(() => throws.Should().ThrowAsync<InvalidOperationException>("Wrong Message"))
+            .Throws<AssertionException>().WithMessage("Value should have Message \"Wrong Message\" but was \"Test\".");
+        await Assert.That(() => throwsAsync.Should().ThrowAsync<InvalidOperationException>("Wrong Message"))
+            .Throws<AssertionException>().WithMessage("Value should have Message \"Wrong Message\" but was \"Test\".");
+
+        await Assert.That(() => doesNotThrow.Should().ThrowAsync<InvalidOperationException>("Test"))
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException.");
+        await Assert.That(() => doesNotThrowAsync.Should().ThrowAsync<InvalidOperationException>("Test"))
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException.");
+
+        await Assert.That(() => throwsWrongException.Should().ThrowAsync<InvalidOperationException>("Test"))
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException but threw a NotSupportedException with message \"Wrong\".");
+        await Assert.That(() => throwsWrongExceptionAsync.Should().ThrowAsync<InvalidOperationException>("Test"))
+            .Throws<AssertionException>().WithMessage("Function should throw an InvalidOperationException but threw a NotSupportedException with message \"Wrong\".");
+    }
+
+    [Test]
+    public async Task ThrowAsync_String_Chain()
+    {
+        var exception = new InvalidOperationException("Test");
+        Func<Task> throws = () => throw exception;
+        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+
+        var chain = await throws.Should().ThrowAsync<InvalidOperationException>("Test").ConfigureAwait(false);
+        await Assert.That(chain.Exception).IsSameReferenceAs(exception);
+        await Assert.That(chain.That).IsSameReferenceAs(exception);
+
+        chain = await throwsAsync.Should().ThrowAsync<InvalidOperationException>("Test").ConfigureAwait(false);
+        await Assert.That(chain.Exception).IsSameReferenceAs(exception);
+        await Assert.That(chain.That).IsSameReferenceAs(exception);
+    }
+
+    [Test]
+    public async Task NotThrowAsync()
+    {
+        Func<Task> doesNotThrow = () => Task.CompletedTask;
+        Func<Task> doesNotThrowAsync = async () => await Task.Yield();
+
+        var exception = new InvalidOperationException("Test");
+        Func<Task> throws = () => throw exception;
+        Func<Task> throwsAsync = async () => { await Task.Yield(); throw exception; };
+
+        await Assert.That(() => doesNotThrow.Should().NotThrowAsync()).ThrowsNothing();
+        await Assert.That(() => doesNotThrowAsync.Should().NotThrowAsync()).ThrowsNothing();
+
+        var actualException = await Assert.That(() => throws.Should().NotThrowAsync())
+            .Throws<AssertionException>()
+            .WithMessage("Function should not throw but threw an InvalidOperationException with message \"Test\".");
+        await Assert.That(actualException!.InnerException).IsSameReferenceAs(exception);
+
+        actualException = await Assert.That(() => throwsAsync.Should().NotThrowAsync())
+            .Throws<AssertionException>()
+            .WithMessage("Function should not throw but threw an InvalidOperationException with message \"Test\".");
+        await Assert.That(actualException!.InnerException).IsSameReferenceAs(exception);
+    }
+
+    [Test]
+    public async Task Awaiting_InvokingExtensions()
+    {
+        var value = new TestClass();
+
+        await Assert.That(() => value.Awaiting(v => v.ThrowAsync()).Should().ThrowAsync<InvalidOperationException>())
+            .ThrowsNothing();
+
+        await Assert.That(() => value.Awaiting(v => v.NotThrowAsync()).Should().NotThrowAsync())
+            .ThrowsNothing();
+    }
+
+    [Test]
+    public async Task Awaiting_InvokingExtensions_WithReturn()
+    {
+        var value = new TestClass();
+
+        await Assert.That(() => value.Awaiting(v => v.ThrowWithReturnAsync()).Should().ThrowAsync<InvalidOperationException>())
+            .ThrowsNothing();
+    }
+
+    private sealed class TestClass
+    {
+        public Task ThrowAsync() => throw new InvalidOperationException();
+
+        public async Task NotThrowAsync() => await Task.Yield();
+
+        public Task<string> ThrowWithReturnAsync() => throw new InvalidOperationException();
+    }
+}
diff --git a/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
index 4369be5..986bcd9 100644
--- a/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
+++ b/src/MrKWatkins.Assertions.Tests/EnumerableAssertionsTests.cs
@@ -168,4 +168,33 @@ public async Task NotSequenceEqual_Chain()
         await Assert.That(chain.Value).IsEqualTo(value);
         await Assert.That(chain.And.Value).IsEqualTo(value);
     }
+
+    [Test]
+    public async Task Contain_Null()
+    {
+        IEnumerable<int> nullEnumerable = null!;
+
+        await Assert.That(() => nullEnumerable.Should().Contain(1)).Throws<AssertionException>()
+            .WithMessage("Value should not be null.");
+    }
+
+    [Test]
+    public async Task Contain()
+    {
+        var value = new List<int> { 1, 2, 3 };
+
+        await Assert.That(() => value.Should().Contain(2)).ThrowsNothing();
+        await Assert.That(() => value.Should().Contain(5)).Throws<AssertionException>()
+            .WithMessage("Value should contain 5 but did not.");
+    }
+
+    [Test]
+    public async Task Contain_Chain()
+    {
+        var value = new List<int> { 1, 2, 3 };
+
+        var chain = value.Should().Contain(2);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
 }
\ No newline at end of file
diff --git a/src/MrKWatkins.Assertions.Tests/FloatingPointAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/FloatingPointAssertionsTests.cs
new file mode 100644
index 0000000..1f0921b
--- /dev/null
+++ b/src/MrKWatkins.Assertions.Tests/FloatingPointAssertionsTests.cs
@@ -0,0 +1,123 @@
+namespace MrKWatkins.Assertions.Tests;
+
+public sealed class FloatingPointAssertionsTests
+{
+    [Test]
+    public async Task BeApproximately()
+    {
+        const double value = 17.5;
+
+        await Assert.That(() => value.Should().BeApproximately(17.5, 0.1)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeApproximately(17.45, 0.1)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeApproximately(17.55, 0.1)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeApproximately(17.6, 0.1)).Throws<AssertionException>()
+            .WithMessage("Value should be approximately 17.6 (±0.1) but was 17.5.");
+        await Assert.That(() => value.Should().BeApproximately(17.4, 0.1)).Throws<AssertionException>()
+            .WithMessage("Value should be approximately 17.4 (±0.1) but was 17.5.");
+    }
+
+    [Test]
+    public async Task BeApproximately_Float()
+    {
+        const float value = 17.5f;
+
+        await Assert.That(() => value.Should().BeApproximately(17.5f, 0.1f)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeApproximately(17.6f, 0.05f)).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task BeApproximately_Chain()
+    {
+        const double value = 17.5;
+
+        var chain = value.Should().BeApproximately(17.5, 0.1);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeLessThan()
+    {
+        const double value = 5.0;
+
+        await Assert.That(() => value.Should().BeLessThan(10.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThan(5.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be less than 5 (±0.001) but was 5.");
+        await Assert.That(() => value.Should().BeLessThan(1.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be less than 1 (±0.001) but was 5.");
+    }
+
+    [Test]
+    public async Task BeLessThan_Chain()
+    {
+        const double value = 5.0;
+
+        var chain = value.Should().BeLessThan(10.0, 0.001);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeLessThanOrEqualTo()
+    {
+        const double value = 5.0;
+
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(10.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(5.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(1.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be less than or equal to 1 (±0.001) but was 5.");
+    }
+
+    [Test]
+    public async Task BeLessThanOrEqualTo_Chain()
+    {
+        const double value = 5.0;
+
+        var chain = value.Should().BeLessThanOrEqualTo(5.0, 0.001);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeGreaterThan()
+    {
+        const double value = 5.0;
+
+        await Assert.That(() => value.Should().BeGreaterThan(1.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThan(5.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be greater than 5 (±0.001) but was 5.");
+        await Assert.That(() => value.Should().BeGreaterThan(10.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be greater than 10 (±0.001) but was 5.");
+    }
+
+    [Test]
+    public async Task BeGreaterThan_Chain()
+    {
+        const double value = 5.0;
+
+        var chain = value.Should().BeGreaterThan(1.0, 0.001);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeGreaterThanOrEqualTo()
+    {
+        const double value = 5.0;
+
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(1.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(5.0, 0.001)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(10.0, 0.001)).Throws<AssertionException>()
+            .WithMessage("Value should be greater than or equal to 10 (±0.001) but was 5.");
+    }
+
+    [Test]
+    public async Task BeGreaterThanOrEqualTo_Chain()
+    {
+        const double value = 5.0;
+
+        var chain = value.Should().BeGreaterThanOrEqualTo(5.0, 0.001);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+}
diff --git a/src/MrKWatkins.Assertions.Tests/IntegerAssertionsTests.cs b/src/MrKWatkins.Assertions.Tests/IntegerAssertionsTests.cs
index 028feed..8da73ae 100644
--- a/src/MrKWatkins.Assertions.Tests/IntegerAssertionsTests.cs
+++ b/src/MrKWatkins.Assertions.Tests/IntegerAssertionsTests.cs
@@ -270,4 +270,84 @@ public async Task ChainWithInheritedMethods()
         await Assert.That(() => value.Should().BePositive().And.NotEqual(0)).ThrowsNothing();
         await Assert.That(() => value.Should().NotBeZero().And.Equal(42)).ThrowsNothing();
     }
+
+    [Test]
+    public async Task BeLessThan()
+    {
+        const int value = 5;
+
+        await Assert.That(() => value.Should().BeLessThan(10)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThan(5)).Throws<AssertionException>().WithMessage("Value should be less than 5 but was 5.");
+        await Assert.That(() => value.Should().BeLessThan(1)).Throws<AssertionException>().WithMessage("Value should be less than 1 but was 5.");
+    }
+
+    [Test]
+    public async Task BeLessThan_Chain()
+    {
+        const int value = 5;
+
+        var chain = value.Should().BeLessThan(10);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeLessThanOrEqualTo()
+    {
+        const int value = 5;
+
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(10)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(5)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeLessThanOrEqualTo(1)).Throws<AssertionException>().WithMessage("Value should be less than or equal to 1 but was 5.");
+    }
+
+    [Test]
+    public async Task BeLessThanOrEqualTo_Chain()
+    {
+        const int value = 5;
+
+        var chain = value.Should().BeLessThanOrEqualTo(5);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeGreaterThan()
+    {
+        const int value = 5;
+
+        await Assert.That(() => value.Should().BeGreaterThan(1)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThan(5)).Throws<AssertionException>().WithMessage("Value should be greater than 5 but was 5.");
+        await Assert.That(() => value.Should().BeGreaterThan(10)).Throws<AssertionException>().WithMessage("Value should be greater than 10 but was 5.");
+    }
+
+    [Test]
+    public async Task BeGreaterThan_Chain()
+    {
+        const int value = 5;
+
+        var chain = value.Should().BeGreaterThan(1);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
+
+    [Test]
+    public async Task BeGreaterThanOrEqualTo()
+    {
+        const int value = 5;
+
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(1)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(5)).ThrowsNothing();
+        await Assert.That(() => value.Should().BeGreaterThanOrEqualTo(10)).Throws<AssertionException>().WithMessage("Value should be greater than or equal to 10 but was 5.");
+    }
+
+    [Test]
+    public async Task BeGreaterThanOrEqualTo_Chain()
+    {
+        const int value = 5;
+
+        var chain = value.Should().BeGreaterThanOrEqualTo(5);
+        await Assert.That(chain.Value).IsEqualTo(value);
+        await Assert.That(chain.And.Value).IsEqualTo(value);
+    }
 }
diff --git a/src/MrKWatkins.Assertions/AsyncActionAssertions.cs b/src/MrKWatkins.Assertions/AsyncActionAssertions.cs
new file mode 100644
index 0000000..845679c
--- /dev/null
+++ b/src/MrKWatkins.Assertions/AsyncActionAssertions.cs
@@ -0,0 +1,70 @@
+namespace MrKWatkins.Assertions;
+
+/// <summary>
+/// Provides assertions for async actions (delegates returning <see cref="Task"/>), such as verifying that exceptions are thrown.
+/// </summary>
+/// <param name="action">The async action to assert on.</param>
+public sealed class AsyncActionAssertions(Func<Task> action)
+{
+    /// <summary>
+    /// Asserts that the async action throws an exception of the specified type.
+    /// </summary>
+    /// <typeparam name="TException">The expected exception type.</typeparam>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<TException>> ThrowAsync<TException>()
+        where TException : Exception
+    {
+        TException? thrown = null;
+        try
+        {
+            await action().ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            if (exception is not TException typedException)
+            {
+                throw Verify.CreateException($"Function should throw {Format.PrefixWithAOrAn(typeof(TException).Name)} but threw {Format.PrefixWithAOrAn(exception.GetType().Name)} with message {Format.Value(exception.Message)}.", exception);
+            }
+            thrown = typedException;
+        }
+
+        if (thrown == null)
+        {
+            throw Verify.CreateException($"Function should throw {Format.PrefixWithAOrAn(typeof(TException).Name)}.");
+        }
+
+        return new ActionAssertionsChain<TException>(thrown);
+    }
+
+    /// <summary>
+    /// Asserts that the async action throws an exception of the specified type with the specified message.
+    /// </summary>
+    /// <typeparam name="TException">The expected exception type.</typeparam>
+    /// <param name="expectedMessage">The expected exception message.</param>
+    /// <returns>A <see cref="Task{TResult}"/> that resolves to an <see cref="ActionAssertionsChain{TException}" /> containing the thrown exception.</returns>
+    public async Task<ActionAssertionsChain<TException>> ThrowAsync<TException>(string expectedMessage)
+        where TException : Exception
+    {
+        var chain = await ThrowAsync<TException>().ConfigureAwait(false);
+
+        chain.That.Should().HaveMessage(expectedMessage);
+
+        return chain;
+    }
+
+    /// <summary>
+    /// Asserts that the async action does not throw any exception.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> that completes successfully if no exception is thrown.</returns>
+    public async Task NotThrowAsync()
+    {
+        try
+        {
+            await action().ConfigureAwait(false);
+        }
+        catch (Exception exception)
+        {
+            throw Verify.CreateException($"Function should not throw but threw {Format.PrefixWithAOrAn(exception.GetType().Name)} with message {Format.Value(exception.Message)}.", exception);
+        }
+    }
+}
diff --git a/src/MrKWatkins.Assertions/EnumerableAssertions.cs b/src/MrKWatkins.Assertions/EnumerableAssertions.cs
index 9305b69..d609d8d 100644
--- a/src/MrKWatkins.Assertions/EnumerableAssertions.cs
+++ b/src/MrKWatkins.Assertions/EnumerableAssertions.cs
@@ -128,4 +128,18 @@ public EnumerableAssertionsChain<TEnumerable, T> NotSequenceEqual(params IEnumer
 
         return new EnumerableAssertionsChain<TEnumerable, T>(this);
     }
+
+    /// <summary>
+    /// Asserts that the enumerable contains the specified item.
+    /// </summary>
+    /// <param name="expected">The item that should be present in the enumerable.</param>
+    /// <returns>An <see cref="EnumerableAssertionsChain{TEnumerable, T}" /> for chaining further assertions.</returns>
+    public EnumerableAssertionsChain<TEnumerable, T> Contain(T expected)
+    {
+        NotBeNull();
+
+        Verify.That(Value.Contains(expected), $"Value should contain {expected} but did not.");
+
+        return new EnumerableAssertionsChain<TEnumerable, T>(this);
+    }
 }
\ No newline at end of file
diff --git a/src/MrKWatkins.Assertions/FloatingPointAssertions.cs b/src/MrKWatkins.Assertions/FloatingPointAssertions.cs
new file mode 100644
index 0000000..0de0acc
--- /dev/null
+++ b/src/MrKWatkins.Assertions/FloatingPointAssertions.cs
@@ -0,0 +1,77 @@
+using System.Numerics;
+
+namespace MrKWatkins.Assertions;
+
+/// <summary>
+/// Provides assertions for floating-point values.
+/// </summary>
+/// <typeparam name="T">The floating-point type of the value being asserted on.</typeparam>
+/// <param name="value">The value to assert on.</param>
+public sealed class FloatingPointAssertions<T>(T value) : ObjectAssertions<T>(value)
+    where T : struct, IFloatingPoint<T>
+{
+    /// <summary>
+    /// Asserts that the floating-point value is approximately equal to the expected value within the specified precision.
+    /// </summary>
+    /// <param name="expected">The expected value.</param>
+    /// <param name="precision">The maximum allowed difference between the value and the expected value.</param>
+    /// <returns>A <see cref="FloatingPointAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public FloatingPointAssertionsChain<T> BeApproximately(T expected, T precision)
+    {
+        Verify.That(T.Abs(Value - expected) <= precision, $"Value should be approximately {expected} (±{precision}) but was {Value}.");
+
+        return new FloatingPointAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the floating-point value is less than the expected value.
+    /// </summary>
+    /// <param name="expected">The value the floating-point number should be less than.</param>
+    /// <param name="precision">The precision to use for the comparison.</param>
+    /// <returns>A <see cref="FloatingPointAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public FloatingPointAssertionsChain<T> BeLessThan(T expected, T precision)
+    {
+        Verify.That(Value < expected - precision, $"Value should be less than {expected} (±{precision}) but was {Value}.");
+
+        return new FloatingPointAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the floating-point value is less than or equal to the expected value.
+    /// </summary>
+    /// <param name="expected">The value the floating-point number should be less than or equal to.</param>
+    /// <param name="precision">The precision to use for the comparison.</param>
+    /// <returns>A <see cref="FloatingPointAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public FloatingPointAssertionsChain<T> BeLessThanOrEqualTo(T expected, T precision)
+    {
+        Verify.That(Value <= expected + precision, $"Value should be less than or equal to {expected} (±{precision}) but was {Value}.");
+
+        return new FloatingPointAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the floating-point value is greater than the expected value.
+    /// </summary>
+    /// <param name="expected">The value the floating-point number should be greater than.</param>
+    /// <param name="precision">The precision to use for the comparison.</param>
+    /// <returns>A <see cref="FloatingPointAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public FloatingPointAssertionsChain<T> BeGreaterThan(T expected, T precision)
+    {
+        Verify.That(Value > expected + precision, $"Value should be greater than {expected} (±{precision}) but was {Value}.");
+
+        return new FloatingPointAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the floating-point value is greater than or equal to the expected value.
+    /// </summary>
+    /// <param name="expected">The value the floating-point number should be greater than or equal to.</param>
+    /// <param name="precision">The precision to use for the comparison.</param>
+    /// <returns>A <see cref="FloatingPointAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public FloatingPointAssertionsChain<T> BeGreaterThanOrEqualTo(T expected, T precision)
+    {
+        Verify.That(Value >= expected - precision, $"Value should be greater than or equal to {expected} (±{precision}) but was {Value}.");
+
+        return new FloatingPointAssertionsChain<T>(this);
+    }
+}
diff --git a/src/MrKWatkins.Assertions/FloatingPointAssertionsChain.cs b/src/MrKWatkins.Assertions/FloatingPointAssertionsChain.cs
new file mode 100644
index 0000000..c73708a
--- /dev/null
+++ b/src/MrKWatkins.Assertions/FloatingPointAssertionsChain.cs
@@ -0,0 +1,22 @@
+using System.Numerics;
+
+namespace MrKWatkins.Assertions;
+
+/// <summary>
+/// Enables chaining of assertions on a floating-point value after a successful assertion.
+/// </summary>
+/// <typeparam name="T">The floating-point type of the value being asserted on.</typeparam>
+/// <param name="floatingPointAssertions">The assertions object to chain from.</param>
+public readonly struct FloatingPointAssertionsChain<T>(FloatingPointAssertions<T> floatingPointAssertions)
+    where T : struct, IFloatingPoint<T>
+{
+    /// <summary>
+    /// Gets the assertions object for chaining further assertions.
+    /// </summary>
+    public FloatingPointAssertions<T> And { get; } = floatingPointAssertions;
+
+    /// <summary>
+    /// Gets the floating-point value being asserted on.
+    /// </summary>
+    public T Value => And.Value;
+}
diff --git a/src/MrKWatkins.Assertions/IntegerAssertions.cs b/src/MrKWatkins.Assertions/IntegerAssertions.cs
index dc351c5..c67607c 100644
--- a/src/MrKWatkins.Assertions/IntegerAssertions.cs
+++ b/src/MrKWatkins.Assertions/IntegerAssertions.cs
@@ -133,4 +133,52 @@ public IntegerAssertionsChain<T> NotBePositive()
 
         return new IntegerAssertionsChain<T>(this);
     }
+
+    /// <summary>
+    /// Asserts that the integer value is less than the expected value.
+    /// </summary>
+    /// <param name="expected">The value the integer should be less than.</param>
+    /// <returns>An <see cref="IntegerAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public IntegerAssertionsChain<T> BeLessThan(T expected)
+    {
+        Verify.That(Value < expected, $"Value should be less than {expected} but was {Value}.");
+
+        return new IntegerAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the integer value is less than or equal to the expected value.
+    /// </summary>
+    /// <param name="expected">The value the integer should be less than or equal to.</param>
+    /// <returns>An <see cref="IntegerAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public IntegerAssertionsChain<T> BeLessThanOrEqualTo(T expected)
+    {
+        Verify.That(Value <= expected, $"Value should be less than or equal to {expected} but was {Value}.");
+
+        return new IntegerAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the integer value is greater than the expected value.
+    /// </summary>
+    /// <param name="expected">The value the integer should be greater than.</param>
+    /// <returns>An <see cref="IntegerAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public IntegerAssertionsChain<T> BeGreaterThan(T expected)
+    {
+        Verify.That(Value > expected, $"Value should be greater than {expected} but was {Value}.");
+
+        return new IntegerAssertionsChain<T>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the integer value is greater than or equal to the expected value.
+    /// </summary>
+    /// <param name="expected">The value the integer should be greater than or equal to.</param>
+    /// <returns>An <see cref="IntegerAssertionsChain{T}" /> for chaining further assertions.</returns>
+    public IntegerAssertionsChain<T> BeGreaterThanOrEqualTo(T expected)
+    {
+        Verify.That(Value >= expected, $"Value should be greater than or equal to {expected} but was {Value}.");
+
+        return new IntegerAssertionsChain<T>(this);
+    }
 }
diff --git a/src/MrKWatkins.Assertions/InvokingExtensions.cs b/src/MrKWatkins.Assertions/InvokingExtensions.cs
index 2a7e5cc..b70db3a 100644
--- a/src/MrKWatkins.Assertions/InvokingExtensions.cs
+++ b/src/MrKWatkins.Assertions/InvokingExtensions.cs
@@ -25,4 +25,25 @@ public static class InvokingExtensions
     /// <returns>An action that invokes the specified function with the value, for use with <see cref="ShouldExtensions.Should(Action)" />.</returns>
     [Pure]
     public static Action Invoking<T, TResult>(this T value, Func<T, TResult> action) => () => action(value);
+
+    /// <summary>
+    /// Wraps an async action on the specified value for assertion testing.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <param name="value">The value to pass to the async action.</param>
+    /// <param name="action">The async action to test.</param>
+    /// <returns>A <see cref="Func{Task}"/> that invokes the specified async action with the value, for use with <see cref="ShouldExtensions.Should(Func{Task})" />.</returns>
+    [Pure]
+    public static Func<Task> Awaiting<T>(this T value, Func<T, Task> action) => () => action(value);
+
+    /// <summary>
+    /// Wraps an async function on the specified value for assertion testing, discarding the return value.
+    /// </summary>
+    /// <typeparam name="T">The type of the value.</typeparam>
+    /// <typeparam name="TResult">The return type of the async function.</typeparam>
+    /// <param name="value">The value to pass to the async function.</param>
+    /// <param name="action">The async function to test.</param>
+    /// <returns>A <see cref="Func{Task}"/> that invokes the specified async function with the value, for use with <see cref="ShouldExtensions.Should(Func{Task})" />.</returns>
+    [Pure]
+    public static Func<Task> Awaiting<T, TResult>(this T value, Func<T, Task<TResult>> action) => () => action(value);
 }
\ No newline at end of file
diff --git a/src/MrKWatkins.Assertions/ShouldExtensions.cs b/src/MrKWatkins.Assertions/ShouldExtensions.cs
index e5b05e5..dfa3685 100644
--- a/src/MrKWatkins.Assertions/ShouldExtensions.cs
+++ b/src/MrKWatkins.Assertions/ShouldExtensions.cs
@@ -112,6 +112,14 @@ public static ReadOnlyDictionaryAssertions<Dictionary<TKey, TValue>, TKey, TValu
     [Pure]
     public static ActionAssertions Should([InstantHandle] this Action value) => new(value);
 
+    /// <summary>
+    /// Begins a fluent assertion on the specified async action.
+    /// </summary>
+    /// <param name="value">The async action to assert on.</param>
+    /// <returns>An <see cref="AsyncActionAssertions" /> for the async action.</returns>
+    [Pure]
+    public static AsyncActionAssertions Should([InstantHandle] this Func<Task> value) => new(value);
+
     /// <summary>
     /// Begins a fluent assertion on the specified byte value.
     /// </summary>
@@ -201,4 +209,22 @@ public static ReadOnlyDictionaryAssertions<Dictionary<TKey, TValue>, TKey, TValu
     [Pure]
     [OverloadResolutionPriority(10)]
     public static IntegerAssertions<nuint> Should(this nuint value) => new(value);
+
+    /// <summary>
+    /// Begins a fluent assertion on the specified float value.
+    /// </summary>
+    /// <param name="value">The float value to assert on.</param>
+    /// <returns>A <see cref="FloatingPointAssertions{T}" /> for the value.</returns>
+    [Pure]
+    [OverloadResolutionPriority(10)]
+    public static FloatingPointAssertions<float> Should(this float value) => new(value);
+
+    /// <summary>
+    /// Begins a fluent assertion on the specified double value.
+    /// </summary>
+    /// <param name="value">The double value to assert on.</param>
+    /// <returns>A <see cref="FloatingPointAssertions{T}" /> for the value.</returns>
+    [Pure]
+    [OverloadResolutionPriority(10)]
+    public static FloatingPointAssertions<double> Should(this double value) => new(value);
 }
\ No newline at end of file