Add NotContainItemsAssignableTo

Src/FluentAssertions/Collections/GenericCollectionAssertions.cs

@@ -1078,6 +1078,52 @@ public AndConstraint<TAssertions> ContainItemsAssignableTo<TExpectation>(string
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
 
+    /// <summary>
+    /// Asserts that the current collection does not contain any element that is assignable to the type <typeparamref name="TExpectation" />.
+    /// </summary>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+    /// </param>
+    public AndConstraint<TAssertions> NotContainItemsAssignableTo<TExpectation>(string because = "", params object[] becauseArgs) =>
+        NotContainItemsAssignableTo(typeof(TExpectation), because, becauseArgs);
+
+    /// <summary>
+    /// Asserts that the current collection does not contain any element that is assignable to the given type.
+    /// </summary>
+    /// <param name="type">
+    /// Object type that should not be in collection
+    /// </param>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+    /// </param>
+    public AndConstraint<TAssertions> NotContainItemsAssignableTo(Type type, string because = "", params object[] becauseArgs)
+    {
+        Guard.ThrowIfArgumentIsNull(type);
+
+        Execute.Assertion
+            .BecauseOf(because, becauseArgs)
+            .WithExpectation("Expected {context:collection} to not contain any elements assignable to type {0}{reason}, ",
+                type.FullName)
+            .ForCondition(Subject is not null)
+            .FailWith("but found <null>.")
+            .Then
+            .Given(() => Subject.ConvertOrCastToCollection())
+            .ForCondition(subject => subject.All(x => !type.IsAssignableFrom(GetType(x))))
+            .FailWith("but found {0}.", subject => subject.Select(x => GetType(x)))
+            .Then
+            .ClearExpectation();
+
+        return new AndConstraint<TAssertions>((TAssertions)this);
+    }
+
     /// <summary>
     /// Expects the current collection to contain only a single item.
     /// </summary>

Tests/FluentAssertions.Specs/Collections/CollectionAssertionSpecs.NotContainItemsAssignableTo.cs

@@ -0,0 +1,66 @@
+using System;
+using Xunit;
+using Xunit.Sdk;
+
+namespace FluentAssertions.Specs.Collections;
+
+public partial class CollectionAssertionSpecs
+{
+    public class NotContainItemsAssignableTo
+    {
+        [Fact]
+        public void Should_succeed_when_asserting_collection_not_contains_items_assignable_to_type()
+        {
+            // Arrange
+            var collection = new[] { "1", "2", "3" };
+
+            // Act / Assert
+            collection.Should().NotContainItemsAssignableTo<int>();
+        }
+
+        [Fact]
+        public void Should_throw_when_asserting_collection_contains_item_assignable_to_type()
+        {
+            // Arrange
+            var collection = new object[] { 1, "2", "3" };
+
+            // Act
+            var act = () => collection.Should().NotContainItemsAssignableTo<int>();
+
+            // Assert
+            act.Should()
+                .Throw<XunitException>()
+                .WithMessage(
+                    "Expected collection to not contain any elements assignable to type \"System.Int32\", but found {System.Int32, System.String, System.String}.");
+        }
+
+        [Fact]
+        public void Should_throw_when_passed_type_argument_is_null()
+        {
+            // Arrange
+            var collection = new[] { 1, 2, 3 };
+
+            // Act
+            var act = () => collection.Should().NotContainItemsAssignableTo(null);
+
+            // Assert
+            act.Should().Throw<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_collection_is_null()
+        {
+            // Arrange
+            int[] collection = null;
+
+            // Act
+            var act = () => collection.Should().NotContainItemsAssignableTo<int>();
+
+            // Assert
+            act.Should()
+                .Throw<XunitException>()
+                .WithMessage(
+                    "Expected collection to not contain any elements assignable to type \"System.Int32\", but found <null>.");
+        }
+    }
+}

docs/_pages/releases.md

@@ -12,6 +12,7 @@ sidebar:
 ### What's new
 * Added `Be`, `NotBe` and `BeOneOf` for object comparisons with custom comparer - [#2111](https://github.com/fluentassertions/fluentassertions/pull/2111)
 * Added `BeSignedWithPublicKey()` and `BeUnsigned()` for assertions on `Assembly` - [#2207](https://github.com/fluentassertions/fluentassertions/pull/2207)
+* Added `NotContainItemsAssignableTo` for asserting that collection does not contain any item assignable to specific type - [#2266](https://github.com/fluentassertions/fluentassertions/pull/2266)
 
 ### Fixes
 * `because` and `becauseArgs` were not included in the error message when collections of enums were not equivalent - [#2214](https://github.com/fluentassertions/fluentassertions/pull/2214)