diff --git a/TUnit.Assertions.Tests/CollectionNullabilityWarningTests.cs b/TUnit.Assertions.Tests/CollectionNullabilityWarningTests.cs
new file mode 100644
index 0000000000..bf97d635ec
--- /dev/null
+++ b/TUnit.Assertions.Tests/CollectionNullabilityWarningTests.cs
@@ -0,0 +1,299 @@
+namespace TUnit.Assertions.Tests;
+
+/// <summary>
+/// Tests to ensure that Assert.That() accepts nullable collection types without generating
+/// nullability warnings (CS8604, CS8625, etc.). This validates the fix for GitHub issue reporting
+/// false positive nullability warnings for List, IList, Dictionary, IDictionary types.
+/// </summary>
+public class CollectionNullabilityWarningTests
+{
+    // ===================================
+    // List<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableList_AcceptsNullableValue_NoWarning()
+    {
+        List<string>? list = ["a", "b", "c"];
+        await Assert.That(list).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableList_WithNullValue_IsNotNull_Fails()
+    {
+        List<string>? list = null;
+        var action = async () => await Assert.That(list).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableList_WithNullValue_IsNull_Passes()
+    {
+        List<string>? list = null;
+        await Assert.That(list).IsNull();
+    }
+
+    // ===================================
+    // IList<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableIList_AcceptsNullableValue_NoWarning()
+    {
+        IList<string>? list = new List<string> { "a", "b", "c" };
+        await Assert.That(list).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableIList_WithNullValue_IsNotNull_Fails()
+    {
+        IList<string>? list = null;
+        var action = async () => await Assert.That(list).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableIList_WithNullValue_IsNull_Passes()
+    {
+        IList<string>? list = null;
+        await Assert.That(list).IsNull();
+    }
+
+    // ===================================
+    // Dictionary<TKey, TValue>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableDictionary_AcceptsNullableValue_NoWarning()
+    {
+        Dictionary<string, int>? dict = new() { ["key"] = 1 };
+        await Assert.That(dict).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableDictionary_WithNullValue_IsNotNull_Fails()
+    {
+        Dictionary<string, int>? dict = null;
+        var action = async () => await Assert.That(dict).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableDictionary_WithNullValue_IsNull_Passes()
+    {
+        Dictionary<string, int>? dict = null;
+        await Assert.That(dict).IsNull();
+    }
+
+    // ===================================
+    // IDictionary<TKey, TValue>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableIDictionary_AcceptsNullableValue_NoWarning()
+    {
+        IDictionary<string, int>? dict = new Dictionary<string, int> { ["key"] = 1 };
+        await Assert.That(dict).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableIDictionary_WithNullValue_IsNotNull_Fails()
+    {
+        IDictionary<string, int>? dict = null;
+        var action = async () => await Assert.That(dict).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableIDictionary_WithNullValue_IsNull_Passes()
+    {
+        IDictionary<string, int>? dict = null;
+        await Assert.That(dict).IsNull();
+    }
+
+    // ===================================
+    // IReadOnlyDictionary<TKey, TValue>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableIReadOnlyDictionary_AcceptsNullableValue_NoWarning()
+    {
+        IReadOnlyDictionary<string, int>? dict = new Dictionary<string, int> { ["key"] = 1 };
+        await Assert.That(dict).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlyDictionary_WithNullValue_IsNotNull_Fails()
+    {
+        IReadOnlyDictionary<string, int>? dict = null;
+        var action = async () => await Assert.That(dict).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlyDictionary_WithNullValue_IsNull_Passes()
+    {
+        IReadOnlyDictionary<string, int>? dict = null;
+        await Assert.That(dict).IsNull();
+    }
+
+    // ===================================
+    // Array? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableArray_AcceptsNullableValue_NoWarning()
+    {
+        string[]? arr = ["a", "b", "c"];
+        await Assert.That(arr).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableArray_WithNullValue_IsNotNull_Fails()
+    {
+        string[]? arr = null;
+        var action = async () => await Assert.That(arr).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableArray_WithNullValue_IsNull_Passes()
+    {
+        string[]? arr = null;
+        await Assert.That(arr).IsNull();
+    }
+
+    // ===================================
+    // ISet<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableISet_AcceptsNullableValue_NoWarning()
+    {
+        ISet<string>? set = new HashSet<string> { "a", "b", "c" };
+        await Assert.That(set).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableISet_WithNullValue_IsNotNull_Fails()
+    {
+        ISet<string>? set = null;
+        var action = async () => await Assert.That(set).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableISet_WithNullValue_IsNull_Passes()
+    {
+        ISet<string>? set = null;
+        await Assert.That(set).IsNull();
+    }
+
+    // ===================================
+    // HashSet<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableHashSet_AcceptsNullableValue_NoWarning()
+    {
+        HashSet<string>? set = ["a", "b", "c"];
+        await Assert.That(set).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableHashSet_WithNullValue_IsNotNull_Fails()
+    {
+        HashSet<string>? set = null;
+        var action = async () => await Assert.That(set).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableHashSet_WithNullValue_IsNull_Passes()
+    {
+        HashSet<string>? set = null;
+        await Assert.That(set).IsNull();
+    }
+
+#if NET5_0_OR_GREATER
+    // ===================================
+    // IReadOnlySet<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableIReadOnlySet_AcceptsNullableValue_NoWarning()
+    {
+        IReadOnlySet<string>? set = new HashSet<string> { "a", "b", "c" };
+        await Assert.That(set).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlySet_WithNullValue_IsNotNull_Fails()
+    {
+        IReadOnlySet<string>? set = null;
+        var action = async () => await Assert.That(set).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlySet_WithNullValue_IsNull_Passes()
+    {
+        IReadOnlySet<string>? set = null;
+        await Assert.That(set).IsNull();
+    }
+#endif
+
+    // ===================================
+    // IReadOnlyList<T>? Tests
+    // ===================================
+
+    [Test]
+    public async Task NullableIReadOnlyList_AcceptsNullableValue_NoWarning()
+    {
+        IReadOnlyList<string>? list = new List<string> { "a", "b", "c" };
+        await Assert.That(list).IsNotNull();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlyList_WithNullValue_IsNotNull_Fails()
+    {
+        IReadOnlyList<string>? list = null;
+        var action = async () => await Assert.That(list).IsNotNull();
+        await Assert.That(action).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task NullableIReadOnlyList_WithNullValue_IsNull_Passes()
+    {
+        IReadOnlyList<string>? list = null;
+        await Assert.That(list).IsNull();
+    }
+
+    // ===================================
+    // Method parameter tests (original issue scenario)
+    // ===================================
+
+    [Test]
+    public async Task MethodWithNullableListParameter_NoWarning()
+    {
+        List<string>? list = ["test"];
+        await VerifyNotNull(list);
+    }
+
+    [Test]
+    public async Task MethodWithNullableIDictionaryParameter_NoWarning()
+    {
+        IDictionary<string, int>? dict = new Dictionary<string, int> { ["key"] = 1 };
+        await VerifyDictionaryNotNull(dict);
+    }
+
+    private static async Task VerifyNotNull(List<string>? actual)
+    {
+        await Assert.That(actual).IsNotNull();
+    }
+
+    private static async Task VerifyDictionaryNotNull(IDictionary<string, int>? actual)
+    {
+        await Assert.That(actual).IsNotNull();
+    }
+}
diff --git a/TUnit.Assertions/Extensions/Assert.cs b/TUnit.Assertions/Extensions/Assert.cs
index 389202f39a..d79d879444 100644
--- a/TUnit.Assertions/Extensions/Assert.cs
+++ b/TUnit.Assertions/Extensions/Assert.cs
@@ -21,7 +21,7 @@ public static class Assert
     /// </summary>
     [OverloadResolutionPriority(3)]
     public static DictionaryAssertion<TKey, TValue> That<TKey, TValue>(
-        IReadOnlyDictionary<TKey, TValue> value,
+        IReadOnlyDictionary<TKey, TValue>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
         where TKey : notnull
     {
@@ -35,7 +35,7 @@ public static DictionaryAssertion<TKey, TValue> That<TKey, TValue>(
     /// </summary>
     [OverloadResolutionPriority(2)]
     public static MutableDictionaryAssertion<TKey, TValue> That<TKey, TValue>(
-        IDictionary<TKey, TValue> value,
+        IDictionary<TKey, TValue>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
         where TKey : notnull
     {
@@ -108,7 +108,7 @@ public static ReadOnlyMemoryAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(2)]
     public static ReadOnlySetAssertion<TItem> That<TItem>(
-        IReadOnlySet<TItem> value,
+        IReadOnlySet<TItem>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new ReadOnlySetAssertion<TItem>(value, expression ?? "set");
@@ -138,7 +138,7 @@ public static AsyncEnumerableAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(2)]
     public static SetAssertion<TItem> That<TItem>(
-        ISet<TItem> value,
+        ISet<TItem>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new SetAssertion<TItem>(value, expression ?? "set");
@@ -153,7 +153,7 @@ public static SetAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(4)]
     public static ListAssertion<TItem> That<TItem>(
-        IList<TItem> value,
+        IList<TItem>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new ListAssertion<TItem>(value, expression ?? "list");
@@ -166,7 +166,7 @@ public static ListAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(5)]
     public static CollectionAssertion<TItem> That<TItem>(
-        TItem[] value,
+        TItem[]? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new CollectionAssertion<TItem>(value!, expression);
@@ -181,7 +181,7 @@ public static CollectionAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(3)]
     public static ReadOnlyListAssertion<TItem> That<TItem>(
-        IReadOnlyList<TItem> value,
+        IReadOnlyList<TItem>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new ReadOnlyListAssertion<TItem>(value, expression ?? "readOnlyList");
@@ -195,7 +195,7 @@ public static ReadOnlyListAssertion<TItem> That<TItem>(
     /// </summary>
     [OverloadResolutionPriority(3)]
     public static HashSetAssertion<TItem> That<TItem>(
-        HashSet<TItem> value,
+        HashSet<TItem>? value,
         [CallerArgumentExpression(nameof(value))] string? expression = null)
     {
         return new HashSetAssertion<TItem>(value, expression ?? "hashSet");
diff --git a/TUnit.Assertions/Sources/DictionaryAssertion.cs b/TUnit.Assertions/Sources/DictionaryAssertion.cs
index b80c36a8a5..d08ef3fcb5 100644
--- a/TUnit.Assertions/Sources/DictionaryAssertion.cs
+++ b/TUnit.Assertions/Sources/DictionaryAssertion.cs
@@ -13,17 +13,17 @@ namespace TUnit.Assertions.Sources;
 public class DictionaryAssertion<TKey, TValue> : DictionaryAssertionBase<IReadOnlyDictionary<TKey, TValue>, TKey, TValue>
     where TKey : notnull
 {
-    public DictionaryAssertion(IReadOnlyDictionary<TKey, TValue> value, string? expression)
+    public DictionaryAssertion(IReadOnlyDictionary<TKey, TValue>? value, string? expression)
         : base(CreateContext(value, expression))
     {
     }
 
     private static AssertionContext<IReadOnlyDictionary<TKey, TValue>> CreateContext(
-        IReadOnlyDictionary<TKey, TValue> value,
+        IReadOnlyDictionary<TKey, TValue>? value,
         string? expression)
     {
         var expressionBuilder = new StringBuilder();
         expressionBuilder.Append($"Assert.That({expression ?? "?"})");
-        return new AssertionContext<IReadOnlyDictionary<TKey, TValue>>(value, expressionBuilder);
+        return new AssertionContext<IReadOnlyDictionary<TKey, TValue>>(value!, expressionBuilder);
     }
 }
diff --git a/TUnit.Assertions/Sources/ListAssertion.cs b/TUnit.Assertions/Sources/ListAssertion.cs
index 62a26e29b1..0dc4c587ea 100644
--- a/TUnit.Assertions/Sources/ListAssertion.cs
+++ b/TUnit.Assertions/Sources/ListAssertion.cs
@@ -11,7 +11,7 @@ namespace TUnit.Assertions.Sources;
 /// </summary>
 public class ListAssertion<TItem> : ListAssertionBase<IList<TItem>, TItem>
 {
-    public ListAssertion(IList<TItem> value, string? expression)
+    public ListAssertion(IList<TItem>? value, string? expression)
         : base(CreateContext(value, expression))
     {
     }
@@ -22,11 +22,11 @@ internal ListAssertion(AssertionContext<IList<TItem>> context)
     }
 
     private static AssertionContext<IList<TItem>> CreateContext(
-        IList<TItem> value,
+        IList<TItem>? value,
         string? expression)
     {
         var expressionBuilder = new StringBuilder();
         expressionBuilder.Append($"Assert.That({expression ?? "?"})");
-        return new AssertionContext<IList<TItem>>(value, expressionBuilder);
+        return new AssertionContext<IList<TItem>>(value!, expressionBuilder);
     }
 }
diff --git a/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs b/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
index 1ef7569fcd..2d0afd5ae0 100644
--- a/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
+++ b/TUnit.Assertions/Sources/MutableDictionaryAssertion.cs
@@ -13,17 +13,17 @@ namespace TUnit.Assertions.Sources;
 public class MutableDictionaryAssertion<TKey, TValue> : MutableDictionaryAssertionBase<IDictionary<TKey, TValue>, TKey, TValue>
     where TKey : notnull
 {
-    public MutableDictionaryAssertion(IDictionary<TKey, TValue> value, string? expression)
+    public MutableDictionaryAssertion(IDictionary<TKey, TValue>? value, string? expression)
         : base(CreateContext(value, expression))
     {
     }
 
     private static AssertionContext<IDictionary<TKey, TValue>> CreateContext(
-        IDictionary<TKey, TValue> value,
+        IDictionary<TKey, TValue>? value,
         string? expression)
     {
         var expressionBuilder = new StringBuilder();
         expressionBuilder.Append($"Assert.That({expression ?? "?"})");
-        return new AssertionContext<IDictionary<TKey, TValue>>(value, expressionBuilder);
+        return new AssertionContext<IDictionary<TKey, TValue>>(value!, expressionBuilder);
     }
 }
diff --git a/TUnit.Assertions/Sources/SetAssertion.cs b/TUnit.Assertions/Sources/SetAssertion.cs
index 0a44a498cf..155b306051 100644
--- a/TUnit.Assertions/Sources/SetAssertion.cs
+++ b/TUnit.Assertions/Sources/SetAssertion.cs
@@ -15,8 +15,8 @@ public class SetAssertion<TItem> : SetAssertionBase<ISet<TItem>, TItem>, IAssert
     /// <summary>
     /// Creates a new SetAssertion for the given set.
     /// </summary>
-    public SetAssertion(ISet<TItem> value, string expression)
-        : base(new AssertionContext<ISet<TItem>>(new EvaluationContext<ISet<TItem>>(value), CreateExpressionBuilder(expression)))
+    public SetAssertion(ISet<TItem>? value, string expression)
+        : base(new AssertionContext<ISet<TItem>>(new EvaluationContext<ISet<TItem>>(value!), CreateExpressionBuilder(expression)))
     {
     }
 
@@ -53,8 +53,8 @@ public class ReadOnlySetAssertion<TItem> : SetAssertionBase<IReadOnlySet<TItem>,
     /// <summary>
     /// Creates a new ReadOnlySetAssertion for the given read-only set.
     /// </summary>
-    public ReadOnlySetAssertion(IReadOnlySet<TItem> value, string expression)
-        : base(new AssertionContext<IReadOnlySet<TItem>>(new EvaluationContext<IReadOnlySet<TItem>>(value), CreateExpressionBuilder(expression)))
+    public ReadOnlySetAssertion(IReadOnlySet<TItem>? value, string expression)
+        : base(new AssertionContext<IReadOnlySet<TItem>>(new EvaluationContext<IReadOnlySet<TItem>>(value!), CreateExpressionBuilder(expression)))
     {
     }
 
@@ -91,8 +91,8 @@ public class HashSetAssertion<TItem> : SetAssertionBase<HashSet<TItem>, TItem>,
     /// <summary>
     /// Creates a new HashSetAssertion for the given hash set.
     /// </summary>
-    public HashSetAssertion(HashSet<TItem> value, string expression)
-        : base(new AssertionContext<HashSet<TItem>>(new EvaluationContext<HashSet<TItem>>(value), CreateExpressionBuilder(expression)))
+    public HashSetAssertion(HashSet<TItem>? value, string expression)
+        : base(new AssertionContext<HashSet<TItem>>(new EvaluationContext<HashSet<TItem>>(value!), CreateExpressionBuilder(expression)))
     {
     }
 
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 601778c174..5daa46f3f4 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
@@ -181,19 +181,19 @@ namespace
         [.(2)]
         public static .<string> That(string? value, [.("value")] string? expression = null) { }
         [.(3)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(4)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(3)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(<.<TItem>?> func, [.("func")] string? expression = null) { }
         [.(1)]
@@ -206,13 +206,13 @@ namespace
         public static .<TItem> That<TItem>(<TItem> value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(.<TValue> task, [.("task")] string? expression = null) { }
         [.(5)]
-        public static .<TItem> That<TItem>(TItem[] value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(TItem[]? value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(TValue? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
         [.(3)]
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
         public static  Throws( exceptionType,  action) { }
         public static TException Throws<TException>( action)
@@ -5440,7 +5440,7 @@ namespace .Sources
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public DictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -5465,7 +5465,7 @@ namespace .Sources
     }
     public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public HashSetAssertion(.<TItem> value, string expression) { }
+        public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
@@ -5481,7 +5481,7 @@ namespace .Sources
     }
     public class ListAssertion<TItem> : .<.<TItem>, TItem>
     {
-        public ListAssertion(.<TItem> value, string? expression) { }
+        public ListAssertion(.<TItem>? value, string? expression) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -5541,7 +5541,7 @@ namespace .Sources
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public MutableDictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -5565,7 +5565,7 @@ namespace .Sources
     }
     public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public ReadOnlySetAssertion(.<TItem> value, string expression) { }
+        public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
@@ -5591,7 +5591,7 @@ namespace .Sources
     }
     public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public SetAssertion(.<TItem> value, string expression) { }
+        public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>
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 74de9383f0..7763d3aba8 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
@@ -179,13 +179,13 @@ namespace
         public static . That(<.> action, [.("action")] string? expression = null) { }
         public static . That(. task, [.("task")] string? expression = null) { }
         public static .<string> That(string? value, [.("value")] string? expression = null) { }
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
         public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         public static .<TItem> That<TItem>(<.<TItem>?> func, [.("func")] string? expression = null) { }
         public static .<TItem> That<TItem>(<.<.<TItem>?>> func, [.("func")] string? expression = null) { }
         public static .<TValue> That<TValue>(<.<TValue?>> func, [.("func")] string? expression = null) { }
@@ -193,11 +193,11 @@ namespace
         public static .<TItem> That<TItem>(<TItem> value, [.("value")] string? expression = null) { }
         public static .<TItem> That<TItem>(<TItem> value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(.<TValue> task, [.("task")] string? expression = null) { }
-        public static .<TItem> That<TItem>(TItem[] value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(TItem[]? value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(TValue? value, [.("value")] string? expression = null) { }
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
         public static  Throws( exceptionType,  action) { }
         public static TException Throws<TException>( action)
@@ -5389,7 +5389,7 @@ namespace .Sources
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public DictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -5414,7 +5414,7 @@ namespace .Sources
     }
     public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public HashSetAssertion(.<TItem> value, string expression) { }
+        public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
@@ -5430,7 +5430,7 @@ namespace .Sources
     }
     public class ListAssertion<TItem> : .<.<TItem>, TItem>
     {
-        public ListAssertion(.<TItem> value, string? expression) { }
+        public ListAssertion(.<TItem>? value, string? expression) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -5490,7 +5490,7 @@ namespace .Sources
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public MutableDictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -5514,7 +5514,7 @@ namespace .Sources
     }
     public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public ReadOnlySetAssertion(.<TItem> value, string expression) { }
+        public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
@@ -5540,7 +5540,7 @@ namespace .Sources
     }
     public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public SetAssertion(.<TItem> value, string expression) { }
+        public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>
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 227013787d..3ec036ff23 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
@@ -181,19 +181,19 @@ namespace
         [.(2)]
         public static .<string> That(string? value, [.("value")] string? expression = null) { }
         [.(3)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(4)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(3)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TItem> That<TItem>(.<TItem> value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(.<TItem>? value, [.("value")] string? expression = null) { }
         [.(1)]
         public static .<TItem> That<TItem>(<.<TItem>?> func, [.("func")] string? expression = null) { }
         [.(1)]
@@ -206,13 +206,13 @@ namespace
         public static .<TItem> That<TItem>(<TItem> value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(.<TValue> task, [.("task")] string? expression = null) { }
         [.(5)]
-        public static .<TItem> That<TItem>(TItem[] value, [.("value")] string? expression = null) { }
+        public static .<TItem> That<TItem>(TItem[]? value, [.("value")] string? expression = null) { }
         public static .<TValue> That<TValue>(TValue? value, [.("value")] string? expression = null) { }
         [.(2)]
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
         [.(3)]
-        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue> value, [.("value")] string? expression = null)
+        public static .<TKey, TValue> That<TKey, TValue>(.<TKey, TValue>? value, [.("value")] string? expression = null)
             where TKey :  notnull { }
         public static  Throws( exceptionType,  action) { }
         public static TException Throws<TException>( action)
@@ -5440,7 +5440,7 @@ namespace .Sources
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public DictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public DictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public class FuncAssertion<TValue> : ., .<TValue>, .<TValue>
     {
@@ -5465,7 +5465,7 @@ namespace .Sources
     }
     public class HashSetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public HashSetAssertion(.<TItem> value, string expression) { }
+        public HashSetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public abstract class ListAssertionBase<TList, TItem> : .<TList, TItem>
@@ -5481,7 +5481,7 @@ namespace .Sources
     }
     public class ListAssertion<TItem> : .<.<TItem>, TItem>
     {
-        public ListAssertion(.<TItem> value, string? expression) { }
+        public ListAssertion(.<TItem>? value, string? expression) { }
     }
     public class MemoryAndContinuation<TMemory, TItem> : .<TMemory, TItem>
     {
@@ -5541,7 +5541,7 @@ namespace .Sources
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
     {
-        public MutableDictionaryAssertion(.<TKey, TValue> value, string? expression) { }
+        public MutableDictionaryAssertion(.<TKey, TValue>? value, string? expression) { }
     }
     public abstract class ReadOnlyListAssertionBase<TList, TItem> : .<TList, TItem>
         where TList : .<TItem>
@@ -5565,7 +5565,7 @@ namespace .Sources
     }
     public class ReadOnlySetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public ReadOnlySetAssertion(.<TItem> value, string expression) { }
+        public ReadOnlySetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetAndContinuation<TSet, TItem> : .<TSet, TItem>
@@ -5591,7 +5591,7 @@ namespace .Sources
     }
     public class SetAssertion<TItem> : .<.<TItem>, TItem>, ., .<.<TItem>>
     {
-        public SetAssertion(.<TItem> value, string expression) { }
+        public SetAssertion(.<TItem>? value, string expression) { }
         protected override .<TItem> CreateSetAdapter(.<TItem> value) { }
     }
     public class SetOrContinuation<TSet, TItem> : .<TSet, TItem>