From ba632178129dd2cdbffda7cd014b6a6ff0da4e44 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Sun, 24 May 2026 12:16:08 +0100
Subject: [PATCH 1/5] Preserve null assertion chaining

---
 .../AsyncEnumerableAssertionTests.cs          |  15 ++
 .../CollectionAssertionTests.cs               |  21 ++
 .../Conditions/AsyncEnumerableAssertions.cs   |  26 +++
 .../Conditions/CollectionNullAssertion.cs     | 209 +++++++++++++++++-
 .../Sources/AsyncEnumerableAssertionBase.cs   |  18 ++
 .../Sources/CollectionAssertionBase.cs        |  18 ++
 .../Sources/DictionaryAssertionBase.cs        |  18 ++
 TUnit.Assertions/Sources/ListAssertionBase.cs |  18 ++
 .../Sources/MutableDictionaryAssertionBase.cs |  18 ++
 .../Sources/ReadOnlyListAssertionBase.cs      |  18 ++
 TUnit.Assertions/Sources/SetAssertionBase.cs  |  18 ++
 11 files changed, 393 insertions(+), 4 deletions(-)

diff --git a/TUnit.Assertions.Tests/AsyncEnumerableAssertionTests.cs b/TUnit.Assertions.Tests/AsyncEnumerableAssertionTests.cs
index b65f2ed237..2541b0b334 100644
--- a/TUnit.Assertions.Tests/AsyncEnumerableAssertionTests.cs
+++ b/TUnit.Assertions.Tests/AsyncEnumerableAssertionTests.cs
@@ -149,6 +149,21 @@ await Assert.That(items)
             .Or.Contains(99); // First passes, so overall passes
     }
 
+    [Test]
+    public async Task Test_AsyncEnumerable_NullAssertions_Preserve_Chaining()
+    {
+        var items = AsyncRange(1, 5);
+
+        await Assert.That(items)
+            .IsNotNull()
+            .And.Contains(3);
+
+        IAsyncEnumerable<int>? nullItems = null;
+        await Assert.That(nullItems!)
+            .IsNull()
+            .Or.Contains(3);
+    }
+
     // Null handling
     [Test]
     public async Task Test_AsyncEnumerable_Null_Fails()
diff --git a/TUnit.Assertions.Tests/CollectionAssertionTests.cs b/TUnit.Assertions.Tests/CollectionAssertionTests.cs
index 0ba70fb5c0..aba1982a49 100644
--- a/TUnit.Assertions.Tests/CollectionAssertionTests.cs
+++ b/TUnit.Assertions.Tests/CollectionAssertionTests.cs
@@ -108,6 +108,27 @@ public async Task Count_WithInnerAssertion_AllMatch()
         await Assert.That(items).Count(item => item.IsGreaterThan(0)).IsEqualTo(5);
     }
 
+    [Test]
+    public async Task NullAssertions_Preserve_List_Chaining()
+    {
+        var items = new List<int> { 1 };
+
+        await Assert.That(items).IsNotNull().And.ItemAt(0).IsEqualTo(1);
+
+        List<int>? nullItems = null;
+        await Assert.That(nullItems).IsNull().Or.ItemAt(0).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task NullAssertions_Preserve_Dictionary_And_Set_Chaining()
+    {
+        IDictionary<string, int> dictionary = new Dictionary<string, int> { ["one"] = 1 };
+        ISet<int> set = new HashSet<int> { 1 };
+
+        await Assert.That(dictionary).IsNotNull().And.ContainsKey("one");
+        await Assert.That(set).IsNotNull().And.IsSubsetOf([1, 2]);
+    }
+
     [Test]
     public async Task Count_WithInnerAssertion_Lambda_Collection()
     {
diff --git a/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs b/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
index 4767edbd14..8e747ad38b 100644
--- a/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
+++ b/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
@@ -43,6 +43,32 @@ private static async Task<List<TItem>> MaterializeAsync(IAsyncEnumerable<TItem>
     protected abstract AssertionResult CheckMaterialized(List<TItem> items);
 }
 
+internal class AsyncEnumerableNullAssertion<TItem> : AsyncEnumerableAssertionBase<TItem>
+{
+    public AsyncEnumerableNullAssertion(AssertionContext<IAsyncEnumerable<TItem>> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IAsyncEnumerable<TItem>> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class AsyncEnumerableNotNullAssertion<TItem> : AsyncEnumerableAssertionBase<TItem>
+{
+    public AsyncEnumerableNotNullAssertion(AssertionContext<IAsyncEnumerable<TItem>> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IAsyncEnumerable<TItem>> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
 /// <summary>
 /// Asserts that the async enumerable is empty or not empty.
 /// </summary>
diff --git a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
index 94b09acee7..78b5f507ef 100644
--- a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
@@ -1,9 +1,28 @@
 using System.Collections;
+using TUnit.Assertions.Abstractions;
 using TUnit.Assertions.Core;
 using TUnit.Assertions.Sources;
 
 namespace TUnit.Assertions.Conditions;
 
+/// <summary>
+/// Asserts that a collection is null, preserving collection type information.
+/// Extends CollectionAssertionBase to ensure .And and .Or return collection-specific continuations.
+/// </summary>
+internal class CollectionNullAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+    where TCollection : IEnumerable<TItem>
+{
+    public CollectionNullAssertion(AssertionContext<TCollection> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
 /// <summary>
 /// Asserts that a collection is not null, preserving collection type information.
 /// Extends CollectionAssertionBase to ensure .And and .Or return collection-specific continuations.
@@ -17,16 +36,198 @@ public CollectionNotNullAssertion(AssertionContext<TCollection> context)
     }
 
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal class ListNullAssertion<TList, TItem> : ListAssertionBase<TList, TItem>
+    where TList : IList<TItem>
+{
+    public ListNullAssertion(AssertionContext<TList> context)
+        : base(context)
     {
-        var value = metadata.Value;
+    }
 
-        if (value != null)
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class ListNotNullAssertion<TList, TItem> : ListAssertionBase<TList, TItem>
+    where TList : IList<TItem>
+{
+    public ListNotNullAssertion(AssertionContext<TList> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal class ReadOnlyListNullAssertion<TList, TItem> : ReadOnlyListAssertionBase<TList, TItem>
+    where TList : IReadOnlyList<TItem>
+{
+    public ReadOnlyListNullAssertion(AssertionContext<TList> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class ReadOnlyListNotNullAssertion<TList, TItem> : ReadOnlyListAssertionBase<TList, TItem>
+    where TList : IReadOnlyList<TItem>
+{
+    public ReadOnlyListNotNullAssertion(AssertionContext<TList> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal class DictionaryNullAssertion<TDictionary, TKey, TValue> : DictionaryAssertionBase<TDictionary, TKey, TValue>
+    where TDictionary : IReadOnlyDictionary<TKey, TValue>
+    where TKey : notnull
+{
+    public DictionaryNullAssertion(AssertionContext<TDictionary> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class DictionaryNotNullAssertion<TDictionary, TKey, TValue> : DictionaryAssertionBase<TDictionary, TKey, TValue>
+    where TDictionary : IReadOnlyDictionary<TKey, TValue>
+    where TKey : notnull
+{
+    public DictionaryNotNullAssertion(AssertionContext<TDictionary> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal class MutableDictionaryNullAssertion<TDictionary, TKey, TValue> : MutableDictionaryAssertionBase<TDictionary, TKey, TValue>
+    where TDictionary : IDictionary<TKey, TValue>
+    where TKey : notnull
+{
+    public MutableDictionaryNullAssertion(AssertionContext<TDictionary> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class MutableDictionaryNotNullAssertion<TDictionary, TKey, TValue> : MutableDictionaryAssertionBase<TDictionary, TKey, TValue>
+    where TDictionary : IDictionary<TKey, TValue>
+    where TKey : notnull
+{
+    public MutableDictionaryNotNullAssertion(AssertionContext<TDictionary> context)
+        : base(context)
+    {
+    }
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal class SetNullAssertion<TSet, TItem> : SetAssertionBase<TSet, TItem>
+    where TSet : IEnumerable<TItem>
+{
+    private readonly Func<TSet, ISetAdapter<TItem>> _adapterFactory;
+
+    public SetNullAssertion(
+        AssertionContext<TSet> context,
+        Func<TSet, ISetAdapter<TItem>> adapterFactory)
+        : base(context)
+    {
+        _adapterFactory = adapterFactory;
+    }
+
+    protected override ISetAdapter<TItem> CreateSetAdapter(TSet value) => _adapterFactory(value);
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TSet> metadata)
+        => NullCheck.CheckIsNull(metadata);
+
+    protected override string GetExpectation() => "to be null";
+}
+
+internal class SetNotNullAssertion<TSet, TItem> : SetAssertionBase<TSet, TItem>
+    where TSet : IEnumerable<TItem>
+{
+    private readonly Func<TSet, ISetAdapter<TItem>> _adapterFactory;
+
+    public SetNotNullAssertion(
+        AssertionContext<TSet> context,
+        Func<TSet, ISetAdapter<TItem>> adapterFactory)
+        : base(context)
+    {
+        _adapterFactory = adapterFactory;
+    }
+
+    protected override ISetAdapter<TItem> CreateSetAdapter(TSet value) => _adapterFactory(value);
+
+    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TSet> metadata)
+        => NullCheck.CheckIsNotNull(metadata);
+
+    protected override string GetExpectation() => "to not be null";
+}
+
+internal static class NullCheck
+{
+    public static Task<AssertionResult> CheckIsNull<TValue>(EvaluationMetadata<TValue> metadata)
+    {
+        if (metadata.Exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {metadata.Exception.GetType().Name}", metadata.Exception));
+        }
+
+        if (metadata.Value is null)
         {
             return AssertionResult._passedTask;
         }
 
-        return Task.FromResult(AssertionResult.Failed("value is null"));
+        return Task.FromResult(AssertionResult.Failed("value is not null"));
     }
 
-    protected override string GetExpectation() => "to not be null";
+    public static Task<AssertionResult> CheckIsNotNull<TValue>(EvaluationMetadata<TValue> metadata)
+    {
+        if (metadata.Exception != null)
+        {
+            return Task.FromResult(AssertionResult.Failed($"threw {metadata.Exception.GetType().Name}", metadata.Exception));
+        }
+
+        if (metadata.Value is not null)
+        {
+            return AssertionResult._passedTask;
+        }
+
+        return Task.FromResult(AssertionResult.Failed("value is null"));
+    }
 }
diff --git a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs b/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
index 7ae256b726..5481870ef4 100644
--- a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
+++ b/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
@@ -39,6 +39,24 @@ private protected AsyncEnumerableAssertionBase(
 
     protected override string GetExpectation() => "async enumerable assertion";
 
+    /// <summary>
+    /// Asserts that the async enumerable is null while preserving async-enumerable-specific chaining.
+    /// </summary>
+    public AsyncEnumerableAssertionBase<TItem> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new AsyncEnumerableNullAssertion<TItem>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the async enumerable is not null while preserving async-enumerable-specific chaining.
+    /// </summary>
+    public AsyncEnumerableAssertionBase<TItem> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new AsyncEnumerableNotNullAssertion<TItem>(Context);
+    }
+
     /// <summary>
     /// Asserts that the async enumerable is empty.
     /// Example: await Assert.That(asyncEnumerable).IsEmpty();
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index c5d7c24454..40798487c3 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -44,6 +44,24 @@ private protected CollectionAssertionBase(
 
     protected override string GetExpectation() => "collection assertion";
 
+    /// <summary>
+    /// Asserts that the collection is null while preserving collection-specific chaining.
+    /// </summary>
+    public CollectionAssertionBase<TCollection, TItem> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new CollectionNullAssertion<TCollection, TItem>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the collection is not null while preserving collection-specific chaining.
+    /// </summary>
+    public CollectionAssertionBase<TCollection, TItem> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new CollectionNotNullAssertion<TCollection, TItem>(Context);
+    }
+
     /// <summary>
     /// Asserts that the collection is of the specified type and returns an assertion on the casted value.
     /// This allows chaining additional assertions on the typed value.
diff --git a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
index 4be375439b..b483172ef5 100644
--- a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
@@ -40,6 +40,24 @@ private protected DictionaryAssertionBase(
 
     protected override string GetExpectation() => "dictionary assertion";
 
+    /// <summary>
+    /// Asserts that the dictionary is null while preserving dictionary-specific chaining.
+    /// </summary>
+    public new DictionaryAssertionBase<TDictionary, TKey, TValue> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new DictionaryNullAssertion<TDictionary, TKey, TValue>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the dictionary is not null while preserving dictionary-specific chaining.
+    /// </summary>
+    public new DictionaryAssertionBase<TDictionary, TKey, TValue> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new DictionaryNotNullAssertion<TDictionary, TKey, TValue>(Context);
+    }
+
     /// <summary>
     /// Asserts that the dictionary contains the specified key.
     /// This instance method enables calling ContainsKey with proper type inference.
diff --git a/TUnit.Assertions/Sources/ListAssertionBase.cs b/TUnit.Assertions/Sources/ListAssertionBase.cs
index 12365631b9..aca9f29ebc 100644
--- a/TUnit.Assertions/Sources/ListAssertionBase.cs
+++ b/TUnit.Assertions/Sources/ListAssertionBase.cs
@@ -31,6 +31,24 @@ private protected ListAssertionBase(
     {
     }
 
+    /// <summary>
+    /// Asserts that the list is null while preserving list-specific chaining.
+    /// </summary>
+    public new ListAssertionBase<TList, TItem> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new ListNullAssertion<TList, TItem>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the list is not null while preserving list-specific chaining.
+    /// </summary>
+    public new ListAssertionBase<TList, TItem> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new ListNotNullAssertion<TList, TItem>(Context);
+    }
+
     /// <summary>
     /// Asserts that the item at the specified index equals the expected value.
     /// Example: await Assert.That(list).HasItemAt(0, "expected");
diff --git a/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs b/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
index 4b35035413..dccb9e2443 100644
--- a/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
@@ -38,6 +38,24 @@ private protected MutableDictionaryAssertionBase(
 
     protected override string GetExpectation() => "dictionary assertion";
 
+    /// <summary>
+    /// Asserts that the dictionary is null while preserving mutable-dictionary-specific chaining.
+    /// </summary>
+    public new MutableDictionaryAssertionBase<TDictionary, TKey, TValue> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new MutableDictionaryNullAssertion<TDictionary, TKey, TValue>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the dictionary is not null while preserving mutable-dictionary-specific chaining.
+    /// </summary>
+    public new MutableDictionaryAssertionBase<TDictionary, TKey, TValue> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new MutableDictionaryNotNullAssertion<TDictionary, TKey, TValue>(Context);
+    }
+
     /// <summary>
     /// Asserts that the dictionary contains the specified key.
     /// Example: await Assert.That(dictionary).ContainsKey("key1");
diff --git a/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs b/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
index 3d7c8db6ca..4a61a42128 100644
--- a/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
+++ b/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
@@ -33,6 +33,24 @@ private protected ReadOnlyListAssertionBase(
         context.SetPendingLink(previousAssertion, combinerType);
     }
 
+    /// <summary>
+    /// Asserts that the list is null while preserving read-only-list-specific chaining.
+    /// </summary>
+    public new ReadOnlyListAssertionBase<TList, TItem> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new ReadOnlyListNullAssertion<TList, TItem>(Context);
+    }
+
+    /// <summary>
+    /// Asserts that the list is not null while preserving read-only-list-specific chaining.
+    /// </summary>
+    public new ReadOnlyListAssertionBase<TList, TItem> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new ReadOnlyListNotNullAssertion<TList, TItem>(Context);
+    }
+
     /// <summary>
     /// Asserts that the list has an item at the specified index that equals the expected value.
     /// Example: await Assert.That(list).HasItemAt(0, "first");
diff --git a/TUnit.Assertions/Sources/SetAssertionBase.cs b/TUnit.Assertions/Sources/SetAssertionBase.cs
index 62576cbff1..3b41b64cbd 100644
--- a/TUnit.Assertions/Sources/SetAssertionBase.cs
+++ b/TUnit.Assertions/Sources/SetAssertionBase.cs
@@ -43,6 +43,24 @@ private protected SetAssertionBase(
 
     protected override string GetExpectation() => "set assertion";
 
+    /// <summary>
+    /// Asserts that the set is null while preserving set-specific chaining.
+    /// </summary>
+    public new SetAssertionBase<TSet, TItem> IsNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNull()");
+        return new SetNullAssertion<TSet, TItem>(Context, CreateSetAdapter);
+    }
+
+    /// <summary>
+    /// Asserts that the set is not null while preserving set-specific chaining.
+    /// </summary>
+    public new SetAssertionBase<TSet, TItem> IsNotNull()
+    {
+        Context.ExpressionBuilder.Append(".IsNotNull()");
+        return new SetNotNullAssertion<TSet, TItem>(Context, CreateSetAdapter);
+    }
+
     // ========================================
     // Set-specific methods
     // ========================================

From c08259e94e8709280e1cdc0d6d5de183e4014300 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 28 May 2026 18:30:03 +0100
Subject: [PATCH 2/5] chore: update PublicAPI snapshots for IsNull/IsNotNull
 overloads

Accept the new IsNull()/IsNotNull() methods added to the seven
specialized assertion bases (Collection, List, ReadOnlyList,
Dictionary, MutableDictionary, Set, AsyncEnumerable) into the
PublicAPI verified snapshots across net8.0, net9.0, net10.0,
and net472.
---
 ...rary_Has_No_API_Changes.DotNet10_0.verified.txt | 14 ++++++++++++++
 ...brary_Has_No_API_Changes.DotNet8_0.verified.txt | 14 ++++++++++++++
 ...brary_Has_No_API_Changes.DotNet9_0.verified.txt | 14 ++++++++++++++
 ..._Library_Has_No_API_Changes.Net4_7.verified.txt | 14 ++++++++++++++
 4 files changed, 56 insertions(+)

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 fc2d114091..137a52f8c2 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
@@ -6187,7 +6187,9 @@ namespace .Sources
         public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
+        public .<TItem> IsNotNull() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TItem> IsNull() { }
         public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
     }
     public class AsyncEnumerableAssertion<TItem> : .<TItem>
@@ -6258,7 +6260,9 @@ namespace .Sources
         public .<TSource, TCollection> IsNotAssignableFrom<TSource>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem> IsNotNull() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TCollection, TItem> IsNull() { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
@@ -6303,6 +6307,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6347,6 +6353,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6418,6 +6426,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6434,6 +6444,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6467,6 +6479,8 @@ namespace .Sources
         protected abstract .<TItem> CreateSetAdapter(TSet value);
         public .<TSet, TItem> DoesNotOverlap(.<TItem> other, [.("other")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TSet, TItem> IsNotNull() { }
+        public new .<TSet, TItem> IsNull() { }
         public .<TSet, TItem> IsProperSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsProperSupersetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
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 8783b78802..c0f574a30e 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
@@ -6110,7 +6110,9 @@ namespace .Sources
         public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
+        public .<TItem> IsNotNull() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TItem> IsNull() { }
         public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
     }
     public class AsyncEnumerableAssertion<TItem> : .<TItem>
@@ -6180,7 +6182,9 @@ namespace .Sources
         public .<TSource, TCollection> IsNotAssignableFrom<TSource>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem> IsNotNull() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TCollection, TItem> IsNull() { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
@@ -6225,6 +6229,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6269,6 +6275,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6340,6 +6348,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6356,6 +6366,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6389,6 +6401,8 @@ namespace .Sources
         protected abstract .<TItem> CreateSetAdapter(TSet value);
         public .<TSet, TItem> DoesNotOverlap(.<TItem> other, [.("other")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TSet, TItem> IsNotNull() { }
+        public new .<TSet, TItem> IsNull() { }
         public .<TSet, TItem> IsProperSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsProperSupersetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
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 ed5f733562..ed8723ca6c 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
@@ -6187,7 +6187,9 @@ namespace .Sources
         public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
+        public .<TItem> IsNotNull() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TItem> IsNull() { }
         public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
     }
     public class AsyncEnumerableAssertion<TItem> : .<TItem>
@@ -6258,7 +6260,9 @@ namespace .Sources
         public .<TSource, TCollection> IsNotAssignableFrom<TSource>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem> IsNotNull() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TCollection, TItem> IsNull() { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
@@ -6303,6 +6307,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6347,6 +6353,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6418,6 +6426,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>, .<.<TKey, TValue>, .<TKey, TValue>>, .<.<TKey, TValue>, .<TKey, TValue>>
         where TKey :  notnull
@@ -6434,6 +6444,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -6467,6 +6479,8 @@ namespace .Sources
         protected abstract .<TItem> CreateSetAdapter(TSet value);
         public .<TSet, TItem> DoesNotOverlap(.<TItem> other, [.("other")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TSet, TItem> IsNotNull() { }
+        public new .<TSet, TItem> IsNull() { }
         public .<TSet, TItem> IsProperSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsProperSupersetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
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 b29afe65f8..40e20a1d6d 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
@@ -5305,7 +5305,9 @@ namespace .Sources
         public .<TExpected, .<TItem>> IsNotAssignableFrom<TExpected>() { }
         public .<TExpected, .<TItem>> IsNotAssignableTo<TExpected>() { }
         public .<TItem> IsNotEmpty() { }
+        public .<TItem> IsNotNull() { }
         public .<.<TItem>, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TItem> IsNull() { }
         public .<.<TItem>, TExpected> IsTypeOf<TExpected>() { }
     }
     public class AsyncEnumerableAssertion<TItem> : .<TItem>
@@ -5375,7 +5377,9 @@ namespace .Sources
         public .<TSource, TCollection> IsNotAssignableFrom<TSource>() { }
         public .<TTarget, TCollection> IsNotAssignableTo<TTarget>() { }
         public .<TCollection, TItem> IsNotEmpty() { }
+        public .<TCollection, TItem> IsNotNull() { }
         public .<TCollection, TExpected> IsNotTypeOf<TExpected>() { }
+        public .<TCollection, TItem> IsNull() { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedBy<TKey>(<TItem, TKey> keySelector, .<TKey>? comparer, [.("keySelector")] string? selectorExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem, TKey> IsOrderedByDescending<TKey>(<TItem, TKey> keySelector, [.("keySelector")] string? expression = null) { }
@@ -5419,6 +5423,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class DictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
@@ -5461,6 +5467,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? expression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -5486,6 +5494,8 @@ namespace .Sources
         public .<TDictionary, TKey, TValue> DoesNotContainKey(TKey expectedKey, [.("expectedKey")] string? expression = null) { }
         public .<TDictionary, TKey, TValue> DoesNotContainValue(TValue expectedValue, [.("expectedValue")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TDictionary, TKey, TValue> IsNotNull() { }
+        public new .<TDictionary, TKey, TValue> IsNull() { }
     }
     public class MutableDictionaryAssertion<TKey, TValue> : .<.<TKey, TValue>, TKey, TValue>
         where TKey :  notnull
@@ -5500,6 +5510,8 @@ namespace .Sources
         public new .<TList, TItem> Or { get; }
         public .<TList, TItem> FirstItem() { }
         public .<TList, TItem> HasItemAt(int index, TItem expected, .<TItem>? comparer = null, [.("index")] string? indexExpression = null, [.("expected")] string? expectedExpression = null) { }
+        public new .<TList, TItem> IsNotNull() { }
+        public new .<TList, TItem> IsNull() { }
         public .<TList, TItem> ItemAt(int index, [.("index")] string? indexExpression = null) { }
         public .<TList, TItem> LastItem() { }
     }
@@ -5521,6 +5533,8 @@ namespace .Sources
         protected abstract .<TItem> CreateSetAdapter(TSet value);
         public .<TSet, TItem> DoesNotOverlap(.<TItem> other, [.("other")] string? expression = null) { }
         protected override string GetExpectation() { }
+        public new .<TSet, TItem> IsNotNull() { }
+        public new .<TSet, TItem> IsNull() { }
         public .<TSet, TItem> IsProperSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsProperSupersetOf(.<TItem> other, [.("other")] string? expression = null) { }
         public .<TSet, TItem> IsSubsetOf(.<TItem> other, [.("other")] string? expression = null) { }

From 021d38d79f103cadc82ddd2dce559bd42acb6220 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 28 May 2026 19:24:33 +0100
Subject: [PATCH 3/5] @ refactor(assertions): collapse null-assertion pairs
 into bool expectNull

Addresses PR review: collapse each internal Null/NotNull assertion pair
into a single class parameterized by `bool expectNull`, matching the
existing ItemAt/LastItem convention. 14 classes -> 8 (public
CollectionNotNullAssertion kept for API compatibility).

- Consolidate NullCheck into Check(metadata, expectNull) + Expectation(expectNull)
- Document why SetNullAssertion still carries adapterFactory (abstract contract)
- Add failure-path tests for IsNotNull/IsNull through And/Or chains
@
---
 .../CollectionAssertionTests.cs               |  22 +++
 .../Conditions/AsyncEnumerableAssertions.cs   |  25 +--
 .../Conditions/CollectionNullAssertion.cs     | 180 ++++--------------
 .../Sources/AsyncEnumerableAssertionBase.cs   |   4 +-
 .../Sources/DictionaryAssertionBase.cs        |   4 +-
 TUnit.Assertions/Sources/ListAssertionBase.cs |   4 +-
 .../Sources/MutableDictionaryAssertionBase.cs |   4 +-
 .../Sources/ReadOnlyListAssertionBase.cs      |   4 +-
 TUnit.Assertions/Sources/SetAssertionBase.cs  |   4 +-
 9 files changed, 72 insertions(+), 179 deletions(-)

diff --git a/TUnit.Assertions.Tests/CollectionAssertionTests.cs b/TUnit.Assertions.Tests/CollectionAssertionTests.cs
index aba1982a49..24c21cfb10 100644
--- a/TUnit.Assertions.Tests/CollectionAssertionTests.cs
+++ b/TUnit.Assertions.Tests/CollectionAssertionTests.cs
@@ -129,6 +129,28 @@ public async Task NullAssertions_Preserve_Dictionary_And_Set_Chaining()
         await Assert.That(set).IsNotNull().And.IsSubsetOf([1, 2]);
     }
 
+    [Test]
+    public async Task NullAssertions_IsNotNull_Fails_When_Null_Through_Chain()
+    {
+        List<int>? nullItems = null;
+
+        await Assert.That(async () =>
+            await Assert.That(nullItems).IsNotNull().And.Contains(1)
+        ).Throws<AssertionException>()
+        .WithMessageContaining("to not be null");
+    }
+
+    [Test]
+    public async Task NullAssertions_IsNull_Fails_When_NotNull_Through_Chain()
+    {
+        var items = new List<int> { 1 };
+
+        await Assert.That(async () =>
+            await Assert.That(items).IsNull().Or.Contains(99)
+        ).Throws<AssertionException>()
+        .WithMessageContaining("to be null");
+    }
+
     [Test]
     public async Task Count_WithInnerAssertion_Lambda_Collection()
     {
diff --git a/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs b/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
index 8e747ad38b..423b66af0b 100644
--- a/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
+++ b/TUnit.Assertions/Conditions/AsyncEnumerableAssertions.cs
@@ -43,30 +43,13 @@ private static async Task<List<TItem>> MaterializeAsync(IAsyncEnumerable<TItem>
     protected abstract AssertionResult CheckMaterialized(List<TItem> items);
 }
 
-internal class AsyncEnumerableNullAssertion<TItem> : AsyncEnumerableAssertionBase<TItem>
+internal class AsyncEnumerableNullAssertion<TItem>(AssertionContext<IAsyncEnumerable<TItem>> context, bool expectNull)
+    : AsyncEnumerableAssertionBase<TItem>(context)
 {
-    public AsyncEnumerableNullAssertion(AssertionContext<IAsyncEnumerable<TItem>> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IAsyncEnumerable<TItem>> metadata)
-        => NullCheck.CheckIsNull(metadata);
-
-    protected override string GetExpectation() => "to be null";
-}
-
-internal class AsyncEnumerableNotNullAssertion<TItem> : AsyncEnumerableAssertionBase<TItem>
-{
-    public AsyncEnumerableNotNullAssertion(AssertionContext<IAsyncEnumerable<TItem>> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<IAsyncEnumerable<TItem>> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to not be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
 /// <summary>
diff --git a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
index 78b5f507ef..9678cb6f3e 100644
--- a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
@@ -18,9 +18,9 @@ public CollectionNullAssertion(AssertionContext<TCollection> context)
     }
 
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
-        => NullCheck.CheckIsNull(metadata);
+        => NullCheck.Check(metadata, expectNull: true);
 
-    protected override string GetExpectation() => "to be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull: true);
 }
 
 /// <summary>
@@ -36,198 +36,86 @@ public CollectionNotNullAssertion(AssertionContext<TCollection> context)
     }
 
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
+        => NullCheck.Check(metadata, expectNull: false);
 
-    protected override string GetExpectation() => "to not be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull: false);
 }
 
-internal class ListNullAssertion<TList, TItem> : ListAssertionBase<TList, TItem>
+internal class ListNullAssertion<TList, TItem>(AssertionContext<TList> context, bool expectNull)
+    : ListAssertionBase<TList, TItem>(context)
     where TList : IList<TItem>
 {
-    public ListNullAssertion(AssertionContext<TList> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
-        => NullCheck.CheckIsNull(metadata);
-
-    protected override string GetExpectation() => "to be null";
-}
-
-internal class ListNotNullAssertion<TList, TItem> : ListAssertionBase<TList, TItem>
-    where TList : IList<TItem>
-{
-    public ListNotNullAssertion(AssertionContext<TList> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to not be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
-internal class ReadOnlyListNullAssertion<TList, TItem> : ReadOnlyListAssertionBase<TList, TItem>
+internal class ReadOnlyListNullAssertion<TList, TItem>(AssertionContext<TList> context, bool expectNull)
+    : ReadOnlyListAssertionBase<TList, TItem>(context)
     where TList : IReadOnlyList<TItem>
 {
-    public ReadOnlyListNullAssertion(AssertionContext<TList> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
-        => NullCheck.CheckIsNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
-internal class ReadOnlyListNotNullAssertion<TList, TItem> : ReadOnlyListAssertionBase<TList, TItem>
-    where TList : IReadOnlyList<TItem>
-{
-    public ReadOnlyListNotNullAssertion(AssertionContext<TList> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TList> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
-
-    protected override string GetExpectation() => "to not be null";
-}
-
-internal class DictionaryNullAssertion<TDictionary, TKey, TValue> : DictionaryAssertionBase<TDictionary, TKey, TValue>
+internal class DictionaryNullAssertion<TDictionary, TKey, TValue>(AssertionContext<TDictionary> context, bool expectNull)
+    : DictionaryAssertionBase<TDictionary, TKey, TValue>(context)
     where TDictionary : IReadOnlyDictionary<TKey, TValue>
     where TKey : notnull
 {
-    public DictionaryNullAssertion(AssertionContext<TDictionary> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
-        => NullCheck.CheckIsNull(metadata);
-
-    protected override string GetExpectation() => "to be null";
-}
-
-internal class DictionaryNotNullAssertion<TDictionary, TKey, TValue> : DictionaryAssertionBase<TDictionary, TKey, TValue>
-    where TDictionary : IReadOnlyDictionary<TKey, TValue>
-    where TKey : notnull
-{
-    public DictionaryNotNullAssertion(AssertionContext<TDictionary> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
-
-    protected override string GetExpectation() => "to not be null";
-}
-
-internal class MutableDictionaryNullAssertion<TDictionary, TKey, TValue> : MutableDictionaryAssertionBase<TDictionary, TKey, TValue>
-    where TDictionary : IDictionary<TKey, TValue>
-    where TKey : notnull
-{
-    public MutableDictionaryNullAssertion(AssertionContext<TDictionary> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
-        => NullCheck.CheckIsNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
-internal class MutableDictionaryNotNullAssertion<TDictionary, TKey, TValue> : MutableDictionaryAssertionBase<TDictionary, TKey, TValue>
+internal class MutableDictionaryNullAssertion<TDictionary, TKey, TValue>(AssertionContext<TDictionary> context, bool expectNull)
+    : MutableDictionaryAssertionBase<TDictionary, TKey, TValue>(context)
     where TDictionary : IDictionary<TKey, TValue>
     where TKey : notnull
 {
-    public MutableDictionaryNotNullAssertion(AssertionContext<TDictionary> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TDictionary> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to not be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
-internal class SetNullAssertion<TSet, TItem> : SetAssertionBase<TSet, TItem>
+internal class SetNullAssertion<TSet, TItem>(
+    AssertionContext<TSet> context,
+    Func<TSet, ISetAdapter<TItem>> adapterFactory,
+    bool expectNull)
+    : SetAssertionBase<TSet, TItem>(context)
     where TSet : IEnumerable<TItem>
 {
-    private readonly Func<TSet, ISetAdapter<TItem>> _adapterFactory;
-
-    public SetNullAssertion(
-        AssertionContext<TSet> context,
-        Func<TSet, ISetAdapter<TItem>> adapterFactory)
-        : base(context)
-    {
-        _adapterFactory = adapterFactory;
-    }
-
-    protected override ISetAdapter<TItem> CreateSetAdapter(TSet value) => _adapterFactory(value);
+    // adapterFactory is never invoked on the null-check path (the set is never materialized),
+    // but SetAssertionBase requires CreateSetAdapter, so it must be supplied.
+    protected override ISetAdapter<TItem> CreateSetAdapter(TSet value) => adapterFactory(value);
 
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TSet> metadata)
-        => NullCheck.CheckIsNull(metadata);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => "to be null";
-}
-
-internal class SetNotNullAssertion<TSet, TItem> : SetAssertionBase<TSet, TItem>
-    where TSet : IEnumerable<TItem>
-{
-    private readonly Func<TSet, ISetAdapter<TItem>> _adapterFactory;
-
-    public SetNotNullAssertion(
-        AssertionContext<TSet> context,
-        Func<TSet, ISetAdapter<TItem>> adapterFactory)
-        : base(context)
-    {
-        _adapterFactory = adapterFactory;
-    }
-
-    protected override ISetAdapter<TItem> CreateSetAdapter(TSet value) => _adapterFactory(value);
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TSet> metadata)
-        => NullCheck.CheckIsNotNull(metadata);
-
-    protected override string GetExpectation() => "to not be null";
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
 internal static class NullCheck
 {
-    public static Task<AssertionResult> CheckIsNull<TValue>(EvaluationMetadata<TValue> metadata)
+    public static Task<AssertionResult> Check<TValue>(EvaluationMetadata<TValue> metadata, bool expectNull)
     {
         if (metadata.Exception != null)
         {
             return Task.FromResult(AssertionResult.Failed($"threw {metadata.Exception.GetType().Name}", metadata.Exception));
         }
 
-        if (metadata.Value is null)
+        if (expectNull ? metadata.Value is null : metadata.Value is not null)
         {
             return AssertionResult._passedTask;
         }
 
-        return Task.FromResult(AssertionResult.Failed("value is not null"));
+        return Task.FromResult(AssertionResult.Failed(expectNull ? "value is not null" : "value is null"));
     }
 
-    public static Task<AssertionResult> CheckIsNotNull<TValue>(EvaluationMetadata<TValue> metadata)
-    {
-        if (metadata.Exception != null)
-        {
-            return Task.FromResult(AssertionResult.Failed($"threw {metadata.Exception.GetType().Name}", metadata.Exception));
-        }
-
-        if (metadata.Value is not null)
-        {
-            return AssertionResult._passedTask;
-        }
-
-        return Task.FromResult(AssertionResult.Failed("value is null"));
-    }
+    public static string Expectation(bool expectNull) => expectNull ? "to be null" : "to not be null";
 }
diff --git a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs b/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
index 5481870ef4..91c8c9e13e 100644
--- a/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
+++ b/TUnit.Assertions/Sources/AsyncEnumerableAssertionBase.cs
@@ -45,7 +45,7 @@ private protected AsyncEnumerableAssertionBase(
     public AsyncEnumerableAssertionBase<TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new AsyncEnumerableNullAssertion<TItem>(Context);
+        return new AsyncEnumerableNullAssertion<TItem>(Context, expectNull: true);
     }
 
     /// <summary>
@@ -54,7 +54,7 @@ public AsyncEnumerableAssertionBase<TItem> IsNull()
     public AsyncEnumerableAssertionBase<TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new AsyncEnumerableNotNullAssertion<TItem>(Context);
+        return new AsyncEnumerableNullAssertion<TItem>(Context, expectNull: false);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
index b483172ef5..aea85145de 100644
--- a/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/DictionaryAssertionBase.cs
@@ -46,7 +46,7 @@ private protected DictionaryAssertionBase(
     public new DictionaryAssertionBase<TDictionary, TKey, TValue> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new DictionaryNullAssertion<TDictionary, TKey, TValue>(Context);
+        return new DictionaryNullAssertion<TDictionary, TKey, TValue>(Context, expectNull: true);
     }
 
     /// <summary>
@@ -55,7 +55,7 @@ private protected DictionaryAssertionBase(
     public new DictionaryAssertionBase<TDictionary, TKey, TValue> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new DictionaryNotNullAssertion<TDictionary, TKey, TValue>(Context);
+        return new DictionaryNullAssertion<TDictionary, TKey, TValue>(Context, expectNull: false);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Sources/ListAssertionBase.cs b/TUnit.Assertions/Sources/ListAssertionBase.cs
index aca9f29ebc..18218dc430 100644
--- a/TUnit.Assertions/Sources/ListAssertionBase.cs
+++ b/TUnit.Assertions/Sources/ListAssertionBase.cs
@@ -37,7 +37,7 @@ private protected ListAssertionBase(
     public new ListAssertionBase<TList, TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new ListNullAssertion<TList, TItem>(Context);
+        return new ListNullAssertion<TList, TItem>(Context, expectNull: true);
     }
 
     /// <summary>
@@ -46,7 +46,7 @@ private protected ListAssertionBase(
     public new ListAssertionBase<TList, TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new ListNotNullAssertion<TList, TItem>(Context);
+        return new ListNullAssertion<TList, TItem>(Context, expectNull: false);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs b/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
index dccb9e2443..c94d8a73ba 100644
--- a/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/MutableDictionaryAssertionBase.cs
@@ -44,7 +44,7 @@ private protected MutableDictionaryAssertionBase(
     public new MutableDictionaryAssertionBase<TDictionary, TKey, TValue> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new MutableDictionaryNullAssertion<TDictionary, TKey, TValue>(Context);
+        return new MutableDictionaryNullAssertion<TDictionary, TKey, TValue>(Context, expectNull: true);
     }
 
     /// <summary>
@@ -53,7 +53,7 @@ private protected MutableDictionaryAssertionBase(
     public new MutableDictionaryAssertionBase<TDictionary, TKey, TValue> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new MutableDictionaryNotNullAssertion<TDictionary, TKey, TValue>(Context);
+        return new MutableDictionaryNullAssertion<TDictionary, TKey, TValue>(Context, expectNull: false);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs b/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
index 4a61a42128..d4cd240574 100644
--- a/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
+++ b/TUnit.Assertions/Sources/ReadOnlyListAssertionBase.cs
@@ -39,7 +39,7 @@ private protected ReadOnlyListAssertionBase(
     public new ReadOnlyListAssertionBase<TList, TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new ReadOnlyListNullAssertion<TList, TItem>(Context);
+        return new ReadOnlyListNullAssertion<TList, TItem>(Context, expectNull: true);
     }
 
     /// <summary>
@@ -48,7 +48,7 @@ private protected ReadOnlyListAssertionBase(
     public new ReadOnlyListAssertionBase<TList, TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new ReadOnlyListNotNullAssertion<TList, TItem>(Context);
+        return new ReadOnlyListNullAssertion<TList, TItem>(Context, expectNull: false);
     }
 
     /// <summary>
diff --git a/TUnit.Assertions/Sources/SetAssertionBase.cs b/TUnit.Assertions/Sources/SetAssertionBase.cs
index 3b41b64cbd..a482818907 100644
--- a/TUnit.Assertions/Sources/SetAssertionBase.cs
+++ b/TUnit.Assertions/Sources/SetAssertionBase.cs
@@ -49,7 +49,7 @@ private protected SetAssertionBase(
     public new SetAssertionBase<TSet, TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new SetNullAssertion<TSet, TItem>(Context, CreateSetAdapter);
+        return new SetNullAssertion<TSet, TItem>(Context, CreateSetAdapter, expectNull: true);
     }
 
     /// <summary>
@@ -58,7 +58,7 @@ private protected SetAssertionBase(
     public new SetAssertionBase<TSet, TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new SetNotNullAssertion<TSet, TItem>(Context, CreateSetAdapter);
+        return new SetNullAssertion<TSet, TItem>(Context, CreateSetAdapter, expectNull: false);
     }
 
     // ========================================

From 7dacd23d815a9ae206a4b28e9ebf258cc84c3b74 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 28 May 2026 19:51:43 +0100
Subject: [PATCH 4/5] @ refactor(assertions): address review on null-assertion
 chaining (#6008)

- Remove dead IsNotNull extension method shadowed by the instance method;
  base CollectionAssertionBase.IsNull/IsNotNull now return the concrete
  CollectionNullAssertion/CollectionNotNullAssertion types, restoring the
  specific return type the extension provided.
- Make CollectionNullAssertion public for symmetry with CollectionNotNullAssertion.
- Document why null-check methods use `new` shadowing rather than virtual/override
  (covariant returns are unsafe on the netstandard2.0 target).
- Update public API snapshots.
@
---
 .../Conditions/CollectionNullAssertion.cs        |  2 +-
 .../Extensions/AssertionExtensions.cs            | 16 ----------------
 .../Sources/CollectionAssertionBase.cs           |  9 +++++++--
 ...ry_Has_No_API_Changes.DotNet10_0.verified.txt |  9 +++++++--
 ...ary_Has_No_API_Changes.DotNet8_0.verified.txt |  9 +++++++--
 ...ary_Has_No_API_Changes.DotNet9_0.verified.txt |  9 +++++++--
 ...ibrary_Has_No_API_Changes.Net4_7.verified.txt |  9 +++++++--
 7 files changed, 36 insertions(+), 27 deletions(-)

diff --git a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
index 9678cb6f3e..2924d85918 100644
--- a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
@@ -9,7 +9,7 @@ namespace TUnit.Assertions.Conditions;
 /// Asserts that a collection is null, preserving collection type information.
 /// Extends CollectionAssertionBase to ensure .And and .Or return collection-specific continuations.
 /// </summary>
-internal class CollectionNullAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+public class CollectionNullAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
     where TCollection : IEnumerable<TItem>
 {
     public CollectionNullAssertion(AssertionContext<TCollection> context)
diff --git a/TUnit.Assertions/Extensions/AssertionExtensions.cs b/TUnit.Assertions/Extensions/AssertionExtensions.cs
index d80570af2c..212a334294 100644
--- a/TUnit.Assertions/Extensions/AssertionExtensions.cs
+++ b/TUnit.Assertions/Extensions/AssertionExtensions.cs
@@ -46,22 +46,6 @@ public static NotNullAssertion<TValue> IsNotNull<TValue>(
         return new NotNullAssertion<TValue>(mappedContext);
     }
 
-    /// <summary>
-    /// Asserts that a collection is not null, preserving collection type information.
-    /// Returns a collection-aware assertion that maintains TItem type for proper chaining.
-    /// This overload enables: Assert.That(collection).IsNotNull().And.Contains(x => predicate).
-    /// </summary>
-    public static CollectionNotNullAssertion<TCollection, TItem> IsNotNull<TCollection, TItem>(
-        this CollectionAssertionBase<TCollection, TItem> source)
-        where TCollection : class, IEnumerable<TItem>
-    {
-        var assertionSource = (IAssertionSource<TCollection>)source;
-        assertionSource.Context.ExpressionBuilder.Append(".IsNotNull()");
-        // Map from TCollection? to TCollection (nullable to non-nullable)
-        var mappedContext = assertionSource.Context.Map((TCollection? v) => v!);
-        return new CollectionNotNullAssertion<TCollection, TItem>(mappedContext);
-    }
-
     /// <summary>
     /// Alias for IsEqualTo - asserts that the value is equal to the expected value.
     /// Works with assertions, And, and Or continuations!
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index 40798487c3..7a8de7ae9a 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -44,10 +44,15 @@ private protected CollectionAssertionBase(
 
     protected override string GetExpectation() => "collection assertion";
 
+    // Subclasses hide IsNull/IsNotNull with `public new` to narrow the return type to their own
+    // base (e.g. ListAssertionBase). This is the same idiom used by And/Or below; virtual+override
+    // with covariant returns is avoided because covariant returns are not honored at runtime on the
+    // netstandard2.0 target consumed by .NET Framework.
+
     /// <summary>
     /// Asserts that the collection is null while preserving collection-specific chaining.
     /// </summary>
-    public CollectionAssertionBase<TCollection, TItem> IsNull()
+    public CollectionNullAssertion<TCollection, TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
         return new CollectionNullAssertion<TCollection, TItem>(Context);
@@ -56,7 +61,7 @@ public CollectionAssertionBase<TCollection, TItem> IsNull()
     /// <summary>
     /// Asserts that the collection is not null while preserving collection-specific chaining.
     /// </summary>
-    public CollectionAssertionBase<TCollection, TItem> IsNotNull()
+    public CollectionNotNullAssertion<TCollection, TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
         return new CollectionNotNullAssertion<TCollection, TItem>(Context);
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 137a52f8c2..fa27de7d2a 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
@@ -922,6 +922,13 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
+    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
+    {
+        public CollectionNullAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> context) { }
@@ -2724,8 +2731,6 @@ namespace .Extensions
             where TValue :  class { }
         public static .<TValue> IsNotNull<TValue>(this .<TValue?> source)
             where TValue :  struct { }
-        public static .<TCollection, TItem> IsNotNull<TCollection, TItem>(this .<TCollection, TItem> source)
-            where TCollection :  class, .<TItem> { }
         public static ..IsNotParsableIntoAssertion<T> IsNotParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TValue> IsOfType<TValue>(this .<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..IsParsableIntoAssertion<T> IsParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
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 c0f574a30e..55d8de00de 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
@@ -905,6 +905,13 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
+    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
+    {
+        public CollectionNullAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> context) { }
@@ -2703,8 +2710,6 @@ namespace .Extensions
             where TValue :  class { }
         public static .<TValue> IsNotNull<TValue>(this .<TValue?> source)
             where TValue :  struct { }
-        public static .<TCollection, TItem> IsNotNull<TCollection, TItem>(this .<TCollection, TItem> source)
-            where TCollection :  class, .<TItem> { }
         public static ..IsNotParsableIntoAssertion<T> IsNotParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TValue> IsOfType<TValue>(this .<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..IsParsableIntoAssertion<T> IsParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
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 ed8723ca6c..1bdf38ff56 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
@@ -922,6 +922,13 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
+    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
+    {
+        public CollectionNullAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> context) { }
@@ -2724,8 +2731,6 @@ namespace .Extensions
             where TValue :  class { }
         public static .<TValue> IsNotNull<TValue>(this .<TValue?> source)
             where TValue :  struct { }
-        public static .<TCollection, TItem> IsNotNull<TCollection, TItem>(this .<TCollection, TItem> source)
-            where TCollection :  class, .<TItem> { }
         public static ..IsNotParsableIntoAssertion<T> IsNotParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
         public static .<TValue> IsOfType<TValue>(this .<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..IsParsableIntoAssertion<T> IsParsableInto<[.(..None | ..PublicMethods | ..Interfaces)]  T>(this .<string> source) { }
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 40e20a1d6d..5e7ab6ae0c 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
@@ -762,6 +762,13 @@ namespace .Conditions
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
+    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
+        where TCollection : .<TItem>
+    {
+        public CollectionNullAssertion(.<TCollection> context) { }
+        protected override .<.> CheckAsync(.<TCollection> metadata) { }
+        protected override string GetExpectation() { }
+    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> context) { }
@@ -2429,8 +2436,6 @@ namespace .Extensions
             where TValue :  class { }
         public static .<TValue> IsNotNull<TValue>(this .<TValue?> source)
             where TValue :  struct { }
-        public static .<TCollection, TItem> IsNotNull<TCollection, TItem>(this .<TCollection, TItem> source)
-            where TCollection :  class, .<TItem> { }
         public static ..IsNotParsableIntoAssertion<T> IsNotParsableInto<T>(this .<string> source) { }
         public static .<TValue> IsOfType<TValue>(this .<TValue> source,  expectedType, [.("expectedType")] string? expression = null) { }
         public static ..IsParsableIntoAssertion<T> IsParsableInto<T>(this .<string> source) { }

From 086c190b99521701d40f5df37123bab823019c6d Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 28 May 2026 20:20:08 +0100
Subject: [PATCH 5/5] refactor(assertions): collapse collection null pair +
 align IsNotNull message

Address review on PR #6008:
- Merge public CollectionNullAssertion/CollectionNotNullAssertion into a
  single internal CollectionNullAssertion<TCollection,TItem>(context, bool
  expectNull), matching the consolidated pattern already used by the List/
  ReadOnlyList/Dictionary/Set internal null assertions. IsNull()/IsNotNull()
  now return the CollectionAssertionBase type, halving the added public API.
- Align NotNullAssertion's exception branch to "threw {Type}" (carrying the
  exception) to match NullCheck and the Is(Not)Default family, instead of the
  misleading "received null".
- Update PublicAPI snapshots for all four TFMs.
---
 .../Conditions/CollectionNullAssertion.cs     | 32 +++----------------
 TUnit.Assertions/Conditions/NullAssertion.cs  |  2 +-
 .../Sources/CollectionAssertionBase.cs        |  8 ++---
 ...Has_No_API_Changes.DotNet10_0.verified.txt | 14 --------
 ..._Has_No_API_Changes.DotNet8_0.verified.txt | 14 --------
 ..._Has_No_API_Changes.DotNet9_0.verified.txt | 14 --------
 ...ary_Has_No_API_Changes.Net4_7.verified.txt | 14 --------
 7 files changed, 10 insertions(+), 88 deletions(-)

diff --git a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
index 2924d85918..38530ef317 100644
--- a/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
+++ b/TUnit.Assertions/Conditions/CollectionNullAssertion.cs
@@ -6,39 +6,17 @@
 namespace TUnit.Assertions.Conditions;
 
 /// <summary>
-/// Asserts that a collection is null, preserving collection type information.
+/// Asserts that a collection is null (or not null), preserving collection type information.
 /// Extends CollectionAssertionBase to ensure .And and .Or return collection-specific continuations.
 /// </summary>
-public class CollectionNullAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
+internal class CollectionNullAssertion<TCollection, TItem>(AssertionContext<TCollection> context, bool expectNull)
+    : CollectionAssertionBase<TCollection, TItem>(context)
     where TCollection : IEnumerable<TItem>
 {
-    public CollectionNullAssertion(AssertionContext<TCollection> context)
-        : base(context)
-    {
-    }
-
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
-        => NullCheck.Check(metadata, expectNull: true);
-
-    protected override string GetExpectation() => NullCheck.Expectation(expectNull: true);
-}
-
-/// <summary>
-/// Asserts that a collection is not null, preserving collection type information.
-/// Extends CollectionAssertionBase to ensure .And and .Or return collection-specific continuations.
-/// </summary>
-public class CollectionNotNullAssertion<TCollection, TItem> : CollectionAssertionBase<TCollection, TItem>
-    where TCollection : IEnumerable<TItem>
-{
-    public CollectionNotNullAssertion(AssertionContext<TCollection> context)
-        : base(context)
-    {
-    }
-
-    protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
-        => NullCheck.Check(metadata, expectNull: false);
+        => NullCheck.Check(metadata, expectNull);
 
-    protected override string GetExpectation() => NullCheck.Expectation(expectNull: false);
+    protected override string GetExpectation() => NullCheck.Expectation(expectNull);
 }
 
 internal class ListNullAssertion<TList, TItem>(AssertionContext<TList> context, bool expectNull)
diff --git a/TUnit.Assertions/Conditions/NullAssertion.cs b/TUnit.Assertions/Conditions/NullAssertion.cs
index 2a6c15a742..251a11077e 100644
--- a/TUnit.Assertions/Conditions/NullAssertion.cs
+++ b/TUnit.Assertions/Conditions/NullAssertion.cs
@@ -20,7 +20,7 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TValue> m
     {
         if (metadata.Exception != null)
         {
-            return Task.FromResult(AssertionResult.Failed("received null"));
+            return Task.FromResult(AssertionResult.Failed($"threw {metadata.Exception.GetType().Name}", metadata.Exception));
         }
 
         var value = metadata.Value;
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index 7a8de7ae9a..4490a521af 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -52,19 +52,19 @@ private protected CollectionAssertionBase(
     /// <summary>
     /// Asserts that the collection is null while preserving collection-specific chaining.
     /// </summary>
-    public CollectionNullAssertion<TCollection, TItem> IsNull()
+    public CollectionAssertionBase<TCollection, TItem> IsNull()
     {
         Context.ExpressionBuilder.Append(".IsNull()");
-        return new CollectionNullAssertion<TCollection, TItem>(Context);
+        return new CollectionNullAssertion<TCollection, TItem>(Context, expectNull: true);
     }
 
     /// <summary>
     /// Asserts that the collection is not null while preserving collection-specific chaining.
     /// </summary>
-    public CollectionNotNullAssertion<TCollection, TItem> IsNotNull()
+    public CollectionAssertionBase<TCollection, TItem> IsNotNull()
     {
         Context.ExpressionBuilder.Append(".IsNotNull()");
-        return new CollectionNotNullAssertion<TCollection, TItem>(Context);
+        return new CollectionNullAssertion<TCollection, TItem>(Context, expectNull: false);
     }
 
     /// <summary>
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 fa27de7d2a..3fd6de6860 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
@@ -915,20 +915,6 @@ namespace .Conditions
     }
     public class CollectionMemberAssertionAdapter<TCollection, TItem> : .<TCollection, TItem>
         where TCollection : .<TItem> { }
-    public class CollectionNotNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNotNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
-    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> 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 55d8de00de..abbcb81286 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
@@ -898,20 +898,6 @@ namespace .Conditions
     }
     public class CollectionMemberAssertionAdapter<TCollection, TItem> : .<TCollection, TItem>
         where TCollection : .<TItem> { }
-    public class CollectionNotNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNotNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
-    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> 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 1bdf38ff56..adb56dfc3a 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
@@ -915,20 +915,6 @@ namespace .Conditions
     }
     public class CollectionMemberAssertionAdapter<TCollection, TItem> : .<TCollection, TItem>
         where TCollection : .<TItem> { }
-    public class CollectionNotNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNotNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
-    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> 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 5e7ab6ae0c..3db6f0c9ae 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
@@ -755,20 +755,6 @@ namespace .Conditions
     }
     public class CollectionMemberAssertionAdapter<TCollection, TItem> : .<TCollection, TItem>
         where TCollection : .<TItem> { }
-    public class CollectionNotNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNotNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
-    public class CollectionNullAssertion<TCollection, TItem> : .<TCollection, TItem>
-        where TCollection : .<TItem>
-    {
-        public CollectionNullAssertion(.<TCollection> context) { }
-        protected override .<.> CheckAsync(.<TCollection> metadata) { }
-        protected override string GetExpectation() { }
-    }
     public abstract class ComparerBasedAssertion<TValue, TItem> : .<TValue>
     {
         protected ComparerBasedAssertion(.<TValue> context) { }