diff --git a/src/TestFramework/TestFramework/Assertions/Assert.AreAllDistinct.cs b/src/TestFramework/TestFramework/Assertions/Assert.AreAllDistinct.cs
new file mode 100644
index 0000000000..0929bfe3dc
--- /dev/null
+++ b/src/TestFramework/TestFramework/Assertions/Assert.AreAllDistinct.cs
@@ -0,0 +1,234 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// A collection of helper classes to test various conditions within
+/// unit tests. If the condition being tested is not met, an exception
+/// is thrown.
+/// </summary>
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+#pragma warning disable RS0027 // API with optional parameter(s) should have the most parameters amongst its public overloads
+public sealed partial class Assert
+{
+    #region AreAllDistinct
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are distinct (no two
+    /// elements are equal) and throws an exception if any two elements in the
+    /// collection are equal.
+    /// </summary>
+    /// <typeparam name="T">The type of the collection items.</typeparam>
+    /// <param name="collection">
+    /// The collection in which to search for duplicate elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// at least one duplicate element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one duplicate element.
+    /// </exception>
+    public static void AreAllDistinct<T>([NotNull] IEnumerable<T>? collection, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllDistinct", "collection");
+        AreAllDistinctImpl(collection, EqualityComparer<T>.Default, comparerTypeName: null, message, collectionExpression);
+    }
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are distinct (no two
+    /// elements are equal) using the supplied <paramref name="comparer"/> and throws
+    /// an exception if any two elements in the collection are equal.
+    /// </summary>
+    /// <typeparam name="T">The type of the collection items.</typeparam>
+    /// <param name="collection">
+    /// The collection in which to search for duplicate elements.
+    /// </param>
+    /// <param name="comparer">
+    /// The equality comparer to use when comparing elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// at least one duplicate element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one duplicate element.
+    /// </exception>
+    public static void AreAllDistinct<T>([NotNull] IEnumerable<T>? collection, [NotNull] IEqualityComparer<T>? comparer, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllDistinct", "collection");
+        CheckParameterNotNull(comparer, "Assert.AreAllDistinct", "comparer");
+        AreAllDistinctImpl(collection, comparer, comparerTypeName: comparer.GetType().ToString(), message, collectionExpression);
+    }
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are distinct (no two
+    /// elements are equal) and throws an exception if any two elements in the
+    /// collection are equal.
+    /// </summary>
+    /// <param name="collection">
+    /// The collection in which to search for duplicate elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// at least one duplicate element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one duplicate element.
+    /// </exception>
+    public static void AreAllDistinct([NotNull] IEnumerable? collection, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllDistinct", "collection");
+        AreAllDistinctImpl(collection.Cast<object?>(), EqualityComparer<object?>.Default, comparerTypeName: null, message, collectionExpression);
+    }
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are distinct (no two
+    /// elements are equal) using the supplied <paramref name="comparer"/> and throws
+    /// an exception if any two elements in the collection are equal.
+    /// </summary>
+    /// <param name="collection">
+    /// The collection in which to search for duplicate elements.
+    /// </param>
+    /// <param name="comparer">
+    /// The equality comparer to use when comparing elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// at least one duplicate element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one duplicate element.
+    /// </exception>
+    public static void AreAllDistinct([NotNull] IEnumerable? collection, [NotNull] IEqualityComparer? comparer, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllDistinct", "collection");
+        CheckParameterNotNull(comparer, "Assert.AreAllDistinct", "comparer");
+        AreAllDistinctImpl(collection.Cast<object?>(), new NonGenericEqualityComparerAdapter(comparer), comparerTypeName: comparer.GetType().ToString(), message, collectionExpression);
+    }
+
+#pragma warning disable CS8714 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'notnull' constraint.
+    private static void AreAllDistinctImpl<T>(IEnumerable<T> collection, IEqualityComparer<T> comparer, string? comparerTypeName, string? message, string collectionExpression)
+    {
+        List<T> snapshot = collection is List<T> list ? list : [.. collection];
+
+#pragma warning disable IDE0028 // Collection initialization can be simplified - target-typed `new` cannot pass the comparer in the same syntactic form expected.
+        var seen = new HashSet<T>(comparer);
+#pragma warning restore IDE0028
+
+        bool seenNull = false;
+        List<T>? duplicates = null;
+        HashSet<T>? duplicatesSeen = null;
+        bool nullDuplicateRecorded = false;
+
+        foreach (T item in snapshot)
+        {
+            if (item is null)
+            {
+                if (!seenNull)
+                {
+                    seenNull = true;
+                    continue;
+                }
+
+                if (!nullDuplicateRecorded)
+                {
+                    duplicates ??= [];
+                    duplicates.Add(default!);
+                    nullDuplicateRecorded = true;
+                }
+
+                continue;
+            }
+
+            if (!seen.Add(item))
+            {
+#pragma warning disable IDE0028 // Collection initialization can be simplified - target-typed `new` cannot pass the comparer in the same syntactic form expected.
+                duplicatesSeen ??= new(comparer);
+#pragma warning restore IDE0028
+                if (duplicatesSeen.Add(item))
+                {
+                    duplicates ??= [];
+                    duplicates.Add(item);
+                }
+            }
+        }
+
+        if (duplicates is not null)
+        {
+            ReportAssertAreAllDistinctFailed(snapshot, duplicates, comparerTypeName, message, collectionExpression);
+        }
+    }
+#pragma warning restore CS8714
+
+    [DoesNotReturn]
+    private static void ReportAssertAreAllDistinctFailed<T>(IEnumerable<T> collection, List<T> duplicates, string? comparerTypeName, string? message, string collectionExpression)
+    {
+        string collectionText = AssertionValueRenderer.RenderValue(collection);
+        string duplicatesText = AssertionValueRenderer.RenderValue(duplicates);
+
+        EvidenceBlock evidence = EvidenceBlock.Create()
+            .AddLine("duplicates:", duplicatesText)
+            .AddLine("collection:", collectionText);
+
+        if (comparerTypeName is not null)
+        {
+            evidence.AddLine("comparer:", comparerTypeName);
+        }
+
+        StructuredAssertionMessage structured = new(FrameworkMessages.AreAllDistinctFailedSummary);
+        structured.WithUserMessage(message);
+        structured.WithEvidence(evidence);
+        structured.WithExpectedAndActual(expectedText: null, actualText: collectionText);
+        structured.WithCallSiteExpression(BuildCallSiteWithComparerForCollection("Assert.AreAllDistinct", collectionExpression, comparerTypeName is not null));
+
+        ReportAssertFailed(structured);
+    }
+
+    private static string? BuildCallSiteWithComparerForCollection(string assertionMethodName, string collectionExpression, bool hasComparer)
+    {
+        string? callSite = FormatCallSiteExpression(assertionMethodName, collectionExpression, "<collection>");
+        if (callSite is null || !hasComparer)
+        {
+            return callSite;
+        }
+
+        // FormatCallSiteExpression has no overload accepting a third argument expression; insert
+        // the <comparer> placeholder so the rendered call-site reflects the overload that was actually invoked.
+        Debug.Assert(callSite.Length > 0 && callSite[callSite.Length - 1] == ')', "FormatCallSiteExpression contract: rendered call-site must end with ')'.");
+        return string.Concat(callSite.Remove(callSite.Length - 1), ", <comparer>)");
+    }
+
+    #endregion // AreAllDistinct
+
+    // TODO: Deduplicate with the same adapter in Assert.CollectionEquivalence.cs (introduced by PR #8234)
+    // once both PRs have landed.
+    private sealed class NonGenericEqualityComparerAdapter : IEqualityComparer<object?>
+    {
+        private readonly IEqualityComparer _comparer;
+
+        public NonGenericEqualityComparerAdapter(IEqualityComparer comparer)
+            => _comparer = comparer;
+
+        bool IEqualityComparer<object?>.Equals(object? x, object? y) => _comparer.Equals(x, y);
+
+        int IEqualityComparer<object?>.GetHashCode(object? obj) => obj is null ? 0 : _comparer.GetHashCode(obj);
+    }
+}
diff --git a/src/TestFramework/TestFramework/Assertions/Assert.AreAllNotNull.cs b/src/TestFramework/TestFramework/Assertions/Assert.AreAllNotNull.cs
new file mode 100644
index 0000000000..88b0f15899
--- /dev/null
+++ b/src/TestFramework/TestFramework/Assertions/Assert.AreAllNotNull.cs
@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// A collection of helper classes to test various conditions within
+/// unit tests. If the condition being tested is not met, an exception
+/// is thrown.
+/// </summary>
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+#pragma warning disable RS0027 // API with optional parameter(s) should have the most parameters amongst its public overloads
+public sealed partial class Assert
+{
+    #region AreAllNotNull
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are non-null and throws
+    /// an exception if any element is null.
+    /// </summary>
+    /// <param name="collection">
+    /// The collection in which to search for null elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// a null element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one null element.
+    /// </exception>
+    public static void AreAllNotNull([NotNull] IEnumerable? collection, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllNotNull", "collection");
+        AreAllNotNullImpl(collection.Cast<object?>(), message, collectionExpression);
+    }
+
+    /// <summary>
+    /// Tests whether all items in the specified collection are non-null and throws
+    /// an exception if any element is null.
+    /// </summary>
+    /// <typeparam name="T">The type of the collection items.</typeparam>
+    /// <param name="collection">
+    /// The collection in which to search for null elements.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when <paramref name="collection"/> contains
+    /// a null element. The message is shown in test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or contains at least one null element.
+    /// </exception>
+    public static void AreAllNotNull<T>([NotNull] IEnumerable<T>? collection, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllNotNull", "collection");
+        AreAllNotNullImpl(collection, message, collectionExpression);
+    }
+
+    private static void AreAllNotNullImpl<T>(IEnumerable<T> collection, string? message, string collectionExpression)
+    {
+        List<T> snapshot = collection is List<T> list ? list : [.. collection];
+        List<int>? nullIndices = null;
+        for (int i = 0; i < snapshot.Count; i++)
+        {
+            if (snapshot[i] is null)
+            {
+                nullIndices ??= [];
+                nullIndices.Add(i);
+            }
+        }
+
+        if (nullIndices is not null)
+        {
+            ReportAssertAreAllNotNullFailed(snapshot, nullIndices, message, collectionExpression);
+        }
+    }
+
+    [DoesNotReturn]
+    private static void ReportAssertAreAllNotNullFailed<T>(IEnumerable<T> collection, List<int> nullIndices, string? message, string collectionExpression)
+    {
+        string collectionText = AssertionValueRenderer.RenderValue(collection);
+        string nullIndicesText = AssertionValueRenderer.RenderValue(nullIndices);
+
+        EvidenceBlock evidence = EvidenceBlock.Create()
+            .AddLine("null indices:", nullIndicesText)
+            .AddLine("collection:", collectionText);
+
+        StructuredAssertionMessage structured = new(FrameworkMessages.AreAllNotNullFailedSummary);
+        structured.WithUserMessage(message);
+        structured.WithEvidence(evidence);
+        structured.WithExpectedAndActual(expectedText: null, actualText: collectionText);
+        structured.WithCallSiteExpression(FormatCallSiteExpression("Assert.AreAllNotNull", collectionExpression, "<collection>"));
+
+        ReportAssertFailed(structured);
+    }
+
+    #endregion // AreAllNotNull
+}
diff --git a/src/TestFramework/TestFramework/Assertions/Assert.AreAllOfType.cs b/src/TestFramework/TestFramework/Assertions/Assert.AreAllOfType.cs
new file mode 100644
index 0000000000..5ae37365b4
--- /dev/null
+++ b/src/TestFramework/TestFramework/Assertions/Assert.AreAllOfType.cs
@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// A collection of helper classes to test various conditions within
+/// unit tests. If the condition being tested is not met, an exception
+/// is thrown.
+/// </summary>
+#pragma warning disable RS0026 // Do not add multiple public overloads with optional parameters
+#pragma warning disable RS0027 // API with optional parameter(s) should have the most parameters amongst its public overloads
+public sealed partial class Assert
+{
+    #region AreAllOfType
+
+    /// <summary>
+    /// Tests whether all elements in the specified collection are instances of (or
+    /// derived from) the expected type and throws an exception if the expected type is
+    /// not in the inheritance hierarchy of one or more of the elements, or if any
+    /// element is null.
+    /// </summary>
+    /// <param name="expectedType">
+    /// The expected type of each element of <paramref name="collection"/>.
+    /// </param>
+    /// <param name="collection">
+    /// The collection containing elements the test expects to be of the specified type.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when an element in <paramref name="collection"/>
+    /// is null or not an instance of <paramref name="expectedType"/>. The message is shown in
+    /// test results.
+    /// </param>
+    /// <param name="expectedTypeExpression">
+    /// The syntactic expression of expectedType as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="expectedType"/> or <paramref name="collection"/> is null,
+    /// or some elements of <paramref name="collection"/> are null or do not inherit from /
+    /// implement <paramref name="expectedType"/>.
+    /// </exception>
+    public static void AreAllOfType([NotNull] Type? expectedType, [NotNull] IEnumerable? collection, string? message = "", [CallerArgumentExpression(nameof(expectedType))] string expectedTypeExpression = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(expectedType, "Assert.AreAllOfType", "expectedType");
+        CheckParameterNotNull(collection, "Assert.AreAllOfType", "collection");
+        AreAllOfTypeImpl(collection, expectedType, genericTypeArgumentName: null, message, collectionExpression, expectedTypeExpression);
+    }
+
+    /// <summary>
+    /// Tests whether all elements in the specified collection are instances of (or
+    /// derived from) the expected type and throws an exception if the expected type is
+    /// not in the inheritance hierarchy of one or more of the elements, or if any
+    /// element is null.
+    /// </summary>
+    /// <typeparam name="TExpected">The type each element of <paramref name="collection"/> is expected to be.</typeparam>
+    /// <param name="collection">
+    /// The collection containing elements the test expects to be of the specified type.
+    /// </param>
+    /// <param name="message">
+    /// The message to include in the exception when an element in <paramref name="collection"/>
+    /// is null or not an instance of <typeparamref name="TExpected"/>. The message is shown in
+    /// test results.
+    /// </param>
+    /// <param name="collectionExpression">
+    /// The syntactic expression of collection as given by the compiler via caller argument expression.
+    /// Users shouldn't pass a value for this parameter.
+    /// </param>
+    /// <exception cref="AssertFailedException">
+    /// Thrown if <paramref name="collection"/> is null or some elements of
+    /// <paramref name="collection"/> are null or do not inherit from / implement
+    /// <typeparamref name="TExpected"/>.
+    /// </exception>
+    public static void AreAllOfType<TExpected>([NotNull] IEnumerable? collection, string? message = "", [CallerArgumentExpression(nameof(collection))] string collectionExpression = "")
+    {
+        CheckParameterNotNull(collection, "Assert.AreAllOfType", "collection");
+        AreAllOfTypeImpl(collection, typeof(TExpected), genericTypeArgumentName: "TExpected", message, collectionExpression, expectedTypeExpression: null);
+    }
+
+    private static void AreAllOfTypeImpl(IEnumerable collection, Type expectedType, string? genericTypeArgumentName, string? message, string collectionExpression, string? expectedTypeExpression)
+    {
+        List<object?> snapshot = [.. collection.Cast<object?>()];
+        List<TypeMismatch>? mismatches = null;
+        for (int i = 0; i < snapshot.Count; i++)
+        {
+            object? element = snapshot[i];
+            if (element is null)
+            {
+                mismatches ??= [];
+                mismatches.Add(new TypeMismatch(i, actualType: null));
+            }
+            else if (!expectedType.IsInstanceOfType(element))
+            {
+                mismatches ??= [];
+                mismatches.Add(new TypeMismatch(i, element.GetType()));
+            }
+        }
+
+        if (mismatches is not null)
+        {
+            ReportAssertAreAllOfTypeFailed(snapshot, expectedType, mismatches, genericTypeArgumentName, message, collectionExpression, expectedTypeExpression);
+        }
+    }
+
+    [DoesNotReturn]
+    private static void ReportAssertAreAllOfTypeFailed(IEnumerable<object?> collection, Type expectedType, List<TypeMismatch> mismatches, string? genericTypeArgumentName, string? message, string collectionExpression, string? expectedTypeExpression)
+    {
+        string collectionText = AssertionValueRenderer.RenderValue(collection);
+        string expectedTypeText = $"{expectedType} (or derived)";
+
+        StringBuilder mismatchesBuilder = new();
+        mismatchesBuilder.Append('[');
+        for (int i = 0; i < mismatches.Count; i++)
+        {
+            if (i > 0)
+            {
+                mismatchesBuilder.Append(", ");
+            }
+
+            TypeMismatch mismatch = mismatches[i];
+            mismatchesBuilder.Append("index ").Append(mismatch.Index).Append(": ");
+            if (mismatch.ActualType is null)
+            {
+                mismatchesBuilder.Append("<null>");
+            }
+            else
+            {
+                mismatchesBuilder.Append(mismatch.ActualType);
+            }
+        }
+
+        mismatchesBuilder.Append(']');
+
+        EvidenceBlock evidence = EvidenceBlock.Create()
+            .AddLine("expected type:", expectedTypeText)
+            .AddLine("mismatches:", mismatchesBuilder.ToString())
+            .AddLine("collection:", collectionText);
+
+        string assertionMethodName = genericTypeArgumentName is null
+            ? "Assert.AreAllOfType"
+            : $"Assert.AreAllOfType<{genericTypeArgumentName}>";
+
+        string? callSite = genericTypeArgumentName is null
+            ? FormatCallSiteExpression(assertionMethodName, expectedTypeExpression!, collectionExpression, "<expectedType>", "<collection>")
+            : FormatCallSiteExpression(assertionMethodName, collectionExpression, "<collection>");
+
+        StructuredAssertionMessage structured = new(FrameworkMessages.AreAllOfTypeFailedSummary);
+        structured.WithUserMessage(message);
+        structured.WithEvidence(evidence);
+        structured.WithExpectedAndActual(expectedTypeText, collectionText);
+        structured.WithCallSiteExpression(callSite);
+
+        ReportAssertFailed(structured);
+    }
+
+    private readonly struct TypeMismatch
+    {
+        public TypeMismatch(int index, Type? actualType)
+        {
+            Index = index;
+            ActualType = actualType;
+        }
+
+        public int Index { get; }
+
+        public Type? ActualType { get; }
+    }
+
+    #endregion // AreAllOfType
+}
diff --git a/src/TestFramework/TestFramework/PublicAPI/PublicAPI.Unshipped.txt b/src/TestFramework/TestFramework/PublicAPI/PublicAPI.Unshipped.txt
index b6e5dde3df..b33be34749 100644
--- a/src/TestFramework/TestFramework/PublicAPI/PublicAPI.Unshipped.txt
+++ b/src/TestFramework/TestFramework/PublicAPI/PublicAPI.Unshipped.txt
@@ -2,6 +2,14 @@
 [MSTESTEXP]static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Scope() -> System.IDisposable!
 Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException.ActualText.get -> string?
 Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException.ExpectedText.get -> string?
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllDistinct(System.Collections.IEnumerable? collection, System.Collections.IEqualityComparer? comparer, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllDistinct(System.Collections.IEnumerable? collection, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllDistinct<T>(System.Collections.Generic.IEnumerable<T>? collection, System.Collections.Generic.IEqualityComparer<T>? comparer, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllDistinct<T>(System.Collections.Generic.IEnumerable<T>? collection, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllNotNull(System.Collections.IEnumerable? collection, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllNotNull<T>(System.Collections.Generic.IEnumerable<T>? collection, string? message = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllOfType(System.Type? expectedType, System.Collections.IEnumerable? collection, string? message = "", string! expectedTypeExpression = "", string! collectionExpression = "") -> void
+static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreAllOfType<TExpected>(System.Collections.IEnumerable? collection, string? message = "", string! collectionExpression = "") -> void
 static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEquivalent<T>(T? expected, T? actual, bool strict, string? message = "", string! expectedExpression = "", string! actualExpression = "") -> void
 static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEquivalent<T>(T? expected, T? actual, string? message = "", string! expectedExpression = "", string! actualExpression = "") -> void
 static Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreNotEquivalent<T>(T? notExpected, T? actual, bool strict, string? message = "", string! notExpectedExpression = "", string! actualExpression = "") -> void
diff --git a/src/TestFramework/TestFramework/Resources/FrameworkMessages.resx b/src/TestFramework/TestFramework/Resources/FrameworkMessages.resx
index dd9fc1b561..30692162b0 100644
--- a/src/TestFramework/TestFramework/Resources/FrameworkMessages.resx
+++ b/src/TestFramework/TestFramework/Resources/FrameworkMessages.resx
@@ -479,6 +479,15 @@ Actual: {2}</value>
   <data name="IsNotNullFailedSummary" xml:space="preserve">
     <value>Expected value to not be null.</value>
   </data>
+  <data name="AreAllNotNullFailedSummary" xml:space="preserve">
+    <value>Expected all items in collection to be non-null.</value>
+  </data>
+  <data name="AreAllDistinctFailedSummary" xml:space="preserve">
+    <value>Expected all items in collection to be distinct.</value>
+  </data>
+  <data name="AreAllOfTypeFailedSummary" xml:space="preserve">
+    <value>Expected all items in collection to be of the specified type.</value>
+  </data>
   <data name="MatchesRegexFailedSummary" xml:space="preserve">
     <value>Expected string to match the specified regular expression.</value>
   </data>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.cs.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.cs.xlf
index 59ccc4447e..fcdb0c36a4 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.cs.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.cs.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Byla nalezena duplicitní položka:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Očekáváno:&lt;{1}&gt;. Aktuálně:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.de.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.de.xlf
index 512defa5c8..5e7f1c48d2 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.de.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.de.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Doppeltes Element gefunden: &lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Erwartet:&lt;{1}&gt;. Tatsächlich:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.es.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.es.xlf
index 0e8a5863fd..e82d1f0364 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.es.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.es.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Se encontró un elemento duplicado:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Se esperaba &lt;{1}&gt;, pero es &lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.fr.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.fr.xlf
index f2393eb9c6..1338340da3 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.fr.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.fr.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Un élément dupliqué a été trouvé : &lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Attendu : &lt;{1}&gt;, Réel : &lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.it.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.it.xlf
index 561a73665e..9f26017606 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.it.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.it.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Rilevato elemento duplicato:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Previsto:&lt;{1}&gt;. Effettivo:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ja.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ja.xlf
index 16e474fec9..430fa3d6fb 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ja.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ja.xlf
@@ -17,6 +17,21 @@
         <target state="translated">重複する項目が見つかりました:&lt;{1}&gt;。{0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">&lt;{1}&gt; が必要ですが、&lt;{2}&gt; が指定されました。{0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ko.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ko.xlf
index af329e6b4f..c9f2dd212a 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ko.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ko.xlf
@@ -17,6 +17,21 @@
         <target state="translated">중복된 항목이 있습니다. &lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">예상 값: &lt;{1}&gt;. 실제 값: &lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pl.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pl.xlf
index 2400f343a5..c9b1425b60 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pl.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pl.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Znaleziono duplikat:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Oczekiwana:&lt;{1}&gt;. Rzeczywista:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pt-BR.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pt-BR.xlf
index f154240002..dd34fd89e8 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pt-BR.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.pt-BR.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Item duplicado encontrado:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Esperado:&lt;{1}&gt;. Real:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ru.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ru.xlf
index 723aab1646..4fa3d74ff0 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ru.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.ru.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Обнаружен совпадающий элемент: &lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Ожидается: &lt;{1}&gt;. Фактически: &lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.tr.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.tr.xlf
index 207520dbec..17a10138eb 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.tr.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.tr.xlf
@@ -17,6 +17,21 @@
         <target state="translated">Yinelenen öğe bulundu:&lt;{1}&gt;. {0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">Beklenen:&lt;{1}&gt;. Gerçek:&lt;{2}&gt;. {0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hans.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hans.xlf
index 89894d5145..667f1f5ba8 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hans.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hans.xlf
@@ -17,6 +17,21 @@
         <target state="translated">找到了重复项: &lt;{1}&gt;。{0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">应为: &lt;{1}&gt;，实际为: &lt;{2}&gt;。{0}</target>
diff --git a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hant.xlf b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hant.xlf
index ae7770aaeb..3aeee9b380 100644
--- a/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hant.xlf
+++ b/src/TestFramework/TestFramework/Resources/xlf/FrameworkMessages.zh-Hant.xlf
@@ -17,6 +17,21 @@
         <target state="translated">找到重複的項目: &lt;{1}&gt;。{0}</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="AreAllDistinctFailedSummary">
+        <source>Expected all items in collection to be distinct.</source>
+        <target state="new">Expected all items in collection to be distinct.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllNotNullFailedSummary">
+        <source>Expected all items in collection to be non-null.</source>
+        <target state="new">Expected all items in collection to be non-null.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="AreAllOfTypeFailedSummary">
+        <source>Expected all items in collection to be of the specified type.</source>
+        <target state="new">Expected all items in collection to be of the specified type.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="AreEqualFailMsg">
         <source>Expected:&lt;{1}&gt;. Actual:&lt;{2}&gt;. {0}</source>
         <target state="translated">預期: &lt;{1}&gt;。實際: &lt;{2}&gt;。{0}</target>
diff --git a/test/UnitTests/TestFramework.UnitTests/Assertions/AssertTests.AreAll.cs b/test/UnitTests/TestFramework.UnitTests/Assertions/AssertTests.AreAll.cs
new file mode 100644
index 0000000000..6ae04d2944
--- /dev/null
+++ b/test/UnitTests/TestFramework.UnitTests/Assertions/AssertTests.AreAll.cs
@@ -0,0 +1,665 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.Collections;
+
+using AwesomeAssertions;
+
+using TestFramework.ForTestingMSTest;
+
+namespace Microsoft.VisualStudio.TestPlatform.TestFramework.UnitTests;
+
+public partial class AssertTests : TestContainer
+{
+    #region AreAllNotNull
+
+    public void AreAllNotNull_Generic_NoNulls_ShouldPass()
+        => Assert.AreAllNotNull(new[] { "a", "b", "c" });
+
+    public void AreAllNotNull_Generic_Empty_ShouldPass()
+        => Assert.AreAllNotNull(Array.Empty<string>());
+
+    public void AreAllNotNull_Generic_ValueTypes_ShouldPass()
+        => Assert.AreAllNotNull(new[] { 1, 2, 3 });
+
+    public void AreAllNotNull_Generic_HasNull_ShouldFail()
+    {
+        Action action = () => Assert.AreAllNotNull(new[] { "a", null, "b", null });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be non-null.
+
+                null indices: [1, 3]
+                collection:   ["a", null, "b", null]
+
+                Assert.AreAllNotNull(new[] { "a", null, "b", null })
+                """);
+    }
+
+    public void AreAllNotNull_Generic_WithUserMessage_ShouldFail()
+    {
+        Action action = () => Assert.AreAllNotNull(new[] { "a", null }, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be non-null.
+                User-provided message
+
+                null indices: [1]
+                collection:   ["a", null]
+
+                Assert.AreAllNotNull(new[] { "a", null })
+                """);
+    }
+
+    public void AreAllNotNull_Generic_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllNotNull((IEnumerable<string>?)null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllNotNull failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllNotNull_NonGeneric_NoNulls_ShouldPass()
+    {
+        ArrayList list = ["a", "b", "c"];
+        Assert.AreAllNotNull(list);
+    }
+
+    public void AreAllNotNull_NonGeneric_HasNull_ShouldFail()
+    {
+        ArrayList list = ["a", null, "b"];
+        Action action = () => Assert.AreAllNotNull(list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be non-null.
+
+                null indices: [1]
+                collection:   ["a", null, "b"]
+
+                Assert.AreAllNotNull(list)
+                """);
+    }
+
+    public void AreAllNotNull_NonGeneric_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllNotNull(null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllNotNull failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllNotNull_NonGeneric_WithUserMessage_ShouldFail()
+    {
+        ArrayList list = ["a", null];
+        Action action = () => Assert.AreAllNotNull(list, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be non-null.
+                User-provided message
+
+                null indices: [1]
+                collection:   ["a", null]
+
+                Assert.AreAllNotNull(list)
+                """);
+    }
+
+    public void AreAllNotNull_Generic_NullableValueType_HasNull_ShouldFail()
+    {
+        Action action = () => Assert.AreAllNotNull(new int?[] { 1, null, 3 });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be non-null.
+
+                null indices: [1]
+                collection:   [1, null, 3]
+
+                Assert.AreAllNotNull(new int?[] { 1, null, 3 })
+                """);
+    }
+
+    public void AreAllNotNull_Generic_LazyEnumerable_HasNull_ShouldFail()
+    {
+        static IEnumerable<string?> Lazy()
+        {
+            yield return "a";
+            yield return null;
+            yield return "b";
+        }
+
+        Action action = () => Assert.AreAllNotNull(Lazy());
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("*null indices: [1]*collection:*");
+    }
+
+    #endregion // AreAllNotNull
+
+    #region AreAllDistinct
+
+    public void AreAllDistinct_Generic_AllDistinct_ShouldPass()
+        => Assert.AreAllDistinct(new[] { 1, 2, 3 });
+
+    public void AreAllDistinct_Generic_Empty_ShouldPass()
+        => Assert.AreAllDistinct(Array.Empty<int>());
+
+    public void AreAllDistinct_Generic_SingleNull_ShouldPass()
+        => Assert.AreAllDistinct(new string?[] { "a", null, "b" });
+
+    public void AreAllDistinct_Generic_HasDuplicate_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { 1, 2, 3, 4, 3 });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [3]
+                collection: [1, 2, 3, 4, 3]
+
+                Assert.AreAllDistinct(new[] { 1, 2, 3, 4, 3 })
+                """);
+    }
+
+    public void AreAllDistinct_Generic_HasMultipleDuplicates_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { 1, 2, 3, 2, 1, 1 });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [2, 1]
+                collection: [1, 2, 3, 2, 1, 1]
+
+                Assert.AreAllDistinct(new[] { 1, 2, 3, 2, 1, 1 })
+                """);
+    }
+
+    public void AreAllDistinct_Generic_NullDuplicate_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new string?[] { "a", null, "b", null });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [null]
+                collection: ["a", null, "b", null]
+
+                Assert.AreAllDistinct(new string?[] { "a", null, "b", null })
+                """);
+    }
+
+    public void AreAllDistinct_Generic_WithUserMessage_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { 1, 1 }, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+                User-provided message
+
+                duplicates: [1]
+                collection: [1, 1]
+
+                Assert.AreAllDistinct(new[] { 1, 1 })
+                """);
+    }
+
+    public void AreAllDistinct_Generic_WithComparer_AllDistinct_ShouldPass()
+        => Assert.AreAllDistinct(new[] { "a", "B", "c" }, new CaseInsensitiveStringComparer());
+
+    public void AreAllDistinct_Generic_WithComparer_HasDuplicate_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { "A", "B", "a" }, new CaseInsensitiveStringComparer());
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: ["a"]
+                collection: ["A", "B", "a"]
+                comparer:   CaseInsensitiveStringComparer
+
+                Assert.AreAllDistinct(new[] { "A", "B", "a" }, <comparer>)
+                """);
+    }
+
+    public void AreAllDistinct_Generic_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct((IEnumerable<int>?)null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllDistinct failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllDistinct_Generic_NullComparer_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { 1, 2 }, (IEqualityComparer<int>?)null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllDistinct failed. The parameter 'comparer' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllDistinct_NonGeneric_AllDistinct_ShouldPass()
+    {
+        ArrayList list = [1, "a", 3.5];
+        Assert.AreAllDistinct(list);
+    }
+
+    public void AreAllDistinct_NonGeneric_HasDuplicate_ShouldFail()
+    {
+        ArrayList list = [1, 2, 3, 2];
+        Action action = () => Assert.AreAllDistinct(list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [2]
+                collection: [1, 2, 3, 2]
+
+                Assert.AreAllDistinct(list)
+                """);
+    }
+
+    public void AreAllDistinct_NonGeneric_WithComparer_HasDuplicate_ShouldFail()
+    {
+        ArrayList list = ["A", "B", "a"];
+        Action action = () => Assert.AreAllDistinct(list, new CaseInsensitiveStringComparer());
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: ["a"]
+                collection: ["A", "B", "a"]
+                comparer:   CaseInsensitiveStringComparer
+
+                Assert.AreAllDistinct(list, <comparer>)
+                """);
+    }
+
+    public void AreAllDistinct_NonGeneric_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllDistinct failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllDistinct_NonGeneric_NullComparer_ShouldFail()
+    {
+        ArrayList list = [1, 2];
+        Action action = () => Assert.AreAllDistinct(list, (IEqualityComparer?)null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllDistinct failed. The parameter 'comparer' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllDistinct_NonGeneric_WithUserMessage_ShouldFail()
+    {
+        ArrayList list = [1, 1];
+        Action action = () => Assert.AreAllDistinct(list, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+                User-provided message
+
+                duplicates: [1]
+                collection: [1, 1]
+
+                Assert.AreAllDistinct(list)
+                """);
+    }
+
+    public void AreAllDistinct_NonGeneric_SingleNull_ShouldPass()
+    {
+        ArrayList list = ["a", null, "b"];
+        Assert.AreAllDistinct(list);
+    }
+
+    public void AreAllDistinct_NonGeneric_NullDuplicate_ShouldFail()
+    {
+        ArrayList list = ["a", null, null];
+        Action action = () => Assert.AreAllDistinct(list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [null]
+                collection: ["a", null, null]
+
+                Assert.AreAllDistinct(list)
+                """);
+    }
+
+    public void AreAllDistinct_Generic_ManyNulls_ReportsNullOnce_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new string?[] { null, "a", null, "b", null });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [null]
+                collection: [null, "a", null, "b", null]
+
+                Assert.AreAllDistinct(new string?[] { null, "a", null, "b", null })
+                """);
+    }
+
+    public void AreAllDistinct_Generic_ManyDuplicatesOfSameValue_ReportsValueOnce_ShouldFail()
+    {
+        Action action = () => Assert.AreAllDistinct(new[] { 5, 5, 5, 5 });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be distinct.
+
+                duplicates: [5]
+                collection: [5, 5, 5, 5]
+
+                Assert.AreAllDistinct(new[] { 5, 5, 5, 5 })
+                """);
+    }
+
+    // Pins the current behavior: null elements are short-circuited and never passed to the user-provided comparer.
+    // A comparer that treats null as equal to "" is therefore not consulted, and [null, ""] is considered distinct.
+    public void AreAllDistinct_Generic_ComparerTreatsNullAsEmpty_NullAndEmpty_ShouldPass()
+        => Assert.AreAllDistinct(new string?[] { null, string.Empty }, new NullEqualsEmptyStringComparer());
+
+    // Pins the current behavior: a comparer that throws on null is never invoked with a null argument because
+    // null elements are short-circuited before the comparer is consulted.
+    public void AreAllDistinct_Generic_ComparerThrowsOnNull_WithNulls_ShouldNotInvokeComparerForNull()
+        => Assert.AreAllDistinct(new string?[] { null, "a", "b" }, new ThrowOnNullStringComparer());
+
+    private sealed class CaseInsensitiveStringComparer : IEqualityComparer<string?>, IEqualityComparer
+    {
+        public bool Equals(string? x, string? y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);
+
+        public int GetHashCode(string? obj) => obj is null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj);
+
+        bool IEqualityComparer.Equals(object? x, object? y) => Equals(x as string, y as string);
+
+        int IEqualityComparer.GetHashCode(object obj) => obj is string value ? GetHashCode(value) : 0;
+    }
+
+    private sealed class NullEqualsEmptyStringComparer : IEqualityComparer<string?>
+    {
+        public bool Equals(string? x, string? y) => (x ?? string.Empty) == (y ?? string.Empty);
+
+        public int GetHashCode(string? obj) => (obj ?? string.Empty).GetHashCode();
+    }
+
+    private sealed class ThrowOnNullStringComparer : IEqualityComparer<string?>
+    {
+        public bool Equals(string? x, string? y)
+            => x is null || y is null
+                ? throw new InvalidOperationException("Comparer should not be invoked with null.")
+                : x == y;
+
+        public int GetHashCode(string? obj)
+            => obj is null
+                ? throw new InvalidOperationException("Comparer should not be invoked with null.")
+                : obj.GetHashCode();
+    }
+
+    #endregion // AreAllDistinct
+
+    #region AreAllOfType
+
+    public void AreAllOfType_Generic_AllMatch_ShouldPass()
+        => Assert.AreAllOfType<string>(new object[] { "a", "b", "c" });
+
+    public void AreAllOfType_Generic_DerivedTypes_ShouldPass()
+        => Assert.AreAllOfType<DerivedAllItemsBase>(new object[] { new DerivedAllItemsA(), new DerivedAllItemsB() });
+
+    public void AreAllOfType_Generic_BaseTypeAcceptsDerived_ShouldPass()
+        => Assert.AreAllOfType<object>(new object[] { 1, "two", 3.0 });
+
+    public void AreAllOfType_Generic_Empty_ShouldPass()
+        => Assert.AreAllOfType<string>(Array.Empty<object>());
+
+    public void AreAllOfType_Generic_NullElement_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<string>(new object?[] { "a", null, "b" });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.String (or derived)
+                mismatches:    [index 1: <null>]
+                collection:    ["a", null, "b"]
+
+                Assert.AreAllOfType<TExpected>(new object?[] { "a", null, "b" })
+                """);
+    }
+
+    public void AreAllOfType_Generic_HasMismatch_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<string>(new object[] { "a", 42, "b", true });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.String (or derived)
+                mismatches:    [index 1: System.Int32, index 3: System.Boolean]
+                collection:    ["a", 42, "b", true]
+
+                Assert.AreAllOfType<TExpected>(new object[] { "a", 42, "b", true })
+                """);
+    }
+
+    public void AreAllOfType_Generic_WithUserMessage_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<string>(new object[] { 1 }, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+                User-provided message
+
+                expected type: System.String (or derived)
+                mismatches:    [index 0: System.Int32]
+                collection:    [1]
+
+                Assert.AreAllOfType<TExpected>(new object[] { 1 })
+                """);
+    }
+
+    public void AreAllOfType_Generic_HasMismatch_ShouldPopulateExpectedAndActualPayload()
+    {
+        try
+        {
+            Assert.AreAllOfType<string>(new object[] { 1 });
+        }
+        catch (AssertFailedException ex)
+        {
+            ex.ExpectedText.Should().Be("System.String (or derived)");
+            ex.ActualText.Should().Be("[1]");
+            ex.Data["assert.expected"].Should().Be("System.String (or derived)");
+            ex.Data["assert.actual"].Should().Be("[1]");
+            return;
+        }
+
+        throw new AssertFailedException("Expected AssertFailedException was not thrown.");
+    }
+
+    public void AreAllOfType_Generic_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<string>(null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllOfType failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllOfType_NonGeneric_AllMatch_ShouldPass()
+    {
+        ArrayList list = ["a", "b"];
+        Assert.AreAllOfType(typeof(string), list);
+    }
+
+    public void AreAllOfType_NonGeneric_HasMismatch_ShouldFail()
+    {
+        ArrayList list = ["a", 42];
+        Action action = () => Assert.AreAllOfType(typeof(string), list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.String (or derived)
+                mismatches:    [index 1: System.Int32]
+                collection:    ["a", 42]
+
+                Assert.AreAllOfType(typeof(string), list)
+                """);
+    }
+
+    public void AreAllOfType_NonGeneric_NullCollection_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType(typeof(string), null);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllOfType failed. The parameter 'collection' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllOfType_NonGeneric_NullExpectedType_ShouldFail()
+    {
+        ArrayList list = ["a"];
+        Action action = () => Assert.AreAllOfType(null, list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("Assert.AreAllOfType failed. The parameter 'expectedType' is invalid. The value cannot be null.");
+    }
+
+    public void AreAllOfType_NonGeneric_WithUserMessage_ShouldFail()
+    {
+        ArrayList list = [1];
+        Action action = () => Assert.AreAllOfType(typeof(string), list, "User-provided message");
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+                User-provided message
+
+                expected type: System.String (or derived)
+                mismatches:    [index 0: System.Int32]
+                collection:    [1]
+
+                Assert.AreAllOfType(typeof(string), list)
+                """);
+    }
+
+    public void AreAllOfType_NonGeneric_DerivedTypes_ShouldPass()
+    {
+        ArrayList list = [new DerivedAllItemsA(), new DerivedAllItemsB()];
+        Assert.AreAllOfType(typeof(DerivedAllItemsBase), list);
+    }
+
+    public void AreAllOfType_NonGeneric_NullElement_ShouldFail()
+    {
+        ArrayList list = ["a", null, "b"];
+        Action action = () => Assert.AreAllOfType(typeof(string), list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.String (or derived)
+                mismatches:    [index 1: <null>]
+                collection:    ["a", null, "b"]
+
+                Assert.AreAllOfType(typeof(string), list)
+                """);
+    }
+
+    public void AreAllOfType_NonGeneric_Empty_ShouldPass()
+    {
+        ArrayList list = [];
+        Assert.AreAllOfType(typeof(string), list);
+    }
+
+    public void AreAllOfType_Generic_BoxedValueType_AllMatch_ShouldPass()
+        => Assert.AreAllOfType<int>(new object[] { 1, 2, 3 });
+
+    public void AreAllOfType_Generic_BoxedValueType_HasMismatch_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<int>(new object[] { 1, "x" });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.Int32 (or derived)
+                mismatches:    [index 1: System.String]
+                collection:    [1, "x"]
+
+                Assert.AreAllOfType<TExpected>(new object[] { 1, "x" })
+                """);
+    }
+
+    // Pins the current behavior of `AreAllOfType<T?>` for nullable value types: a `null` element fails because
+    // `typeof(int?).IsInstanceOfType(null)` returns false. Boxed non-null nullable values are accepted because
+    // boxing erases the `Nullable<T>` wrapper.
+    public void AreAllOfType_Generic_NullableValueType_NullElement_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<int?>(new object?[] { 1, null, 3 });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("*mismatches:    [index 1: <null>]*");
+    }
+
+    public void AreAllOfType_Generic_StructMismatch_ShouldFail()
+    {
+        Action action = () => Assert.AreAllOfType<DateTime>(new object[] { DateTime.UtcNow, "x" });
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                *expected type: System.DateTime (or derived)
+                mismatches:    [index 1: System.String]*
+                """);
+    }
+
+    public void AreAllOfType_NonGeneric_BoxedValueType_AllMatch_ShouldPass()
+    {
+        ArrayList list = [1, 2, 3];
+        Assert.AreAllOfType(typeof(int), list);
+    }
+
+    public void AreAllOfType_NonGeneric_BoxedValueType_HasMismatch_ShouldFail()
+    {
+        ArrayList list = [1, "x"];
+        Action action = () => Assert.AreAllOfType(typeof(int), list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage(
+                """
+                Assertion failed. Expected all items in collection to be of the specified type.
+
+                expected type: System.Int32 (or derived)
+                mismatches:    [index 1: System.String]
+                collection:    [1, "x"]
+
+                Assert.AreAllOfType(typeof(int), list)
+                """);
+    }
+
+    public void AreAllOfType_Generic_Interface_AllImplement_ShouldPass()
+        => Assert.AreAllOfType<IDisposable>(new object[] { new System.IO.MemoryStream(), new System.IO.MemoryStream() });
+
+    public void AreAllOfType_NonGeneric_Interface_HasMismatch_ShouldFail()
+    {
+        ArrayList list = [new System.IO.MemoryStream(), "not-disposable-string"];
+        Action action = () => Assert.AreAllOfType(typeof(IDisposable), list);
+        action.Should().Throw<AssertFailedException>()
+            .WithMessage("*expected type: System.IDisposable (or derived)*mismatches:    [index 1: System.String]*");
+    }
+
+    private class DerivedAllItemsBase;
+
+    private sealed class DerivedAllItemsA : DerivedAllItemsBase;
+
+    private sealed class DerivedAllItemsB : DerivedAllItemsBase;
+
+    #endregion // AreAllOfType
+}