diff --git a/TUnit.Assertions/Conditions/HasDistinctItemsAssertion.cs b/TUnit.Assertions/Conditions/HasDistinctItemsAssertion.cs
index f54ac31630..b7a8eb0e45 100644
--- a/TUnit.Assertions/Conditions/HasDistinctItemsAssertion.cs
+++ b/TUnit.Assertions/Conditions/HasDistinctItemsAssertion.cs
@@ -11,12 +11,22 @@ namespace TUnit.Assertions.Conditions;
 public class HasDistinctItemsAssertion<TCollection, TItem> : Sources.CollectionAssertionBase<TCollection, TItem>
     where TCollection : IEnumerable<TItem>
 {
+    private readonly IEqualityComparer<TItem>? _comparer;
+
     public HasDistinctItemsAssertion(
         AssertionContext<TCollection> context)
         : base(context)
     {
     }
 
+    public HasDistinctItemsAssertion(
+        AssertionContext<TCollection> context,
+        IEqualityComparer<TItem> comparer)
+        : base(context)
+    {
+        _comparer = comparer;
+    }
+
     protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollection> metadata)
     {
         if (metadata.Exception != null)
@@ -30,7 +40,7 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TCollecti
         }
 
         var adapter = new EnumerableAdapter<TItem>(metadata.Value);
-        return Task.FromResult(CollectionChecks.CheckHasDistinctItems(adapter));
+        return Task.FromResult(CollectionChecks.CheckHasDistinctItems(adapter, _comparer));
     }
 
     protected override string GetExpectation() => "to have distinct items";
diff --git a/TUnit.Assertions/Conditions/StringEqualsAssertion.cs b/TUnit.Assertions/Conditions/StringEqualsAssertion.cs
index 32e386c21e..82134374ae 100644
--- a/TUnit.Assertions/Conditions/StringEqualsAssertion.cs
+++ b/TUnit.Assertions/Conditions/StringEqualsAssertion.cs
@@ -13,6 +13,7 @@ namespace TUnit.Assertions.Conditions;
 public class StringEqualsAssertion<TActual> : Assertion<TActual>
 {
     private readonly string? _expected;
+    private readonly IEqualityComparer<string>? _comparer;
     private StringComparison _comparison = StringComparison.Ordinal;
     private bool _trimming;
     private bool _nullAndEmptyEquality;
@@ -36,6 +37,16 @@ public StringEqualsAssertion(
         _comparison = comparison;
     }
 
+    public StringEqualsAssertion(
+        AssertionContext<TActual> context,
+        string? expected,
+        IEqualityComparer<string> comparer)
+        : base(context)
+    {
+        _expected = expected;
+        _comparer = comparer;
+    }
+
     /// <summary>
     /// Makes the comparison case-insensitive.
     /// </summary>
@@ -112,6 +123,17 @@ protected override Task<AssertionResult> CheckAsync(EvaluationMetadata<TActual>
             expectedValue = string.IsNullOrEmpty(expectedValue) ? null : expectedValue;
         }
 
+        // When a custom comparer is provided, use it directly
+        if (_comparer != null)
+        {
+            if (_comparer.Equals(actualValue!, expectedValue!))
+            {
+                return AssertionResult._passedTask;
+            }
+
+            return Task.FromResult(AssertionResult.Failed($"found \"{value}\""));
+        }
+
         if (string.Equals(actualValue, expectedValue, _comparison))
         {
             return AssertionResult._passedTask;
diff --git a/TUnit.Assertions/Sources/CollectionAssertionBase.cs b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
index 0a842a097e..a72b6b18cb 100644
--- a/TUnit.Assertions/Sources/CollectionAssertionBase.cs
+++ b/TUnit.Assertions/Sources/CollectionAssertionBase.cs
@@ -91,6 +91,21 @@ public CollectionContainsAssertion<TCollection, TItem> Contains(
         return new CollectionContainsAssertion<TCollection, TItem>(Context, expected);
     }
 
+    /// <summary>
+    /// Asserts that the collection contains the expected item using a custom equality comparer.
+    /// This instance method enables calling Contains with proper type inference and a custom comparer.
+    /// Example: await Assert.That(list).Contains("value", StringComparer.OrdinalIgnoreCase);
+    /// </summary>
+    public CollectionContainsAssertion<TCollection, TItem> Contains(
+        TItem expected,
+        IEqualityComparer<TItem> comparer,
+        [CallerArgumentExpression(nameof(expected))] string? expectedExpression = null,
+        [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
+    {
+        Context.ExpressionBuilder.Append($".Contains({expectedExpression}, {comparerExpression})");
+        return new CollectionContainsAssertion<TCollection, TItem>(Context, expected, comparer);
+    }
+
     /// <summary>
     /// Asserts that the collection contains an item matching the predicate.
     /// This instance method enables calling Contains with proper type inference.
@@ -284,6 +299,19 @@ public HasDistinctItemsAssertion<TCollection, TItem> HasDistinctItems()
         return new HasDistinctItemsAssertion<TCollection, TItem>(Context);
     }
 
+    /// <summary>
+    /// Asserts that the collection contains only distinct (unique) items using a custom equality comparer.
+    /// This instance method enables calling HasDistinctItems with proper type inference and a custom comparer.
+    /// Example: await Assert.That(list).HasDistinctItems(StringComparer.OrdinalIgnoreCase);
+    /// </summary>
+    public HasDistinctItemsAssertion<TCollection, TItem> HasDistinctItems(
+        IEqualityComparer<TItem> comparer,
+        [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
+    {
+        Context.ExpressionBuilder.Append($".HasDistinctItems({comparerExpression})");
+        return new HasDistinctItemsAssertion<TCollection, TItem>(Context, comparer);
+    }
+
     /// <summary>
     /// Asserts that the collection does not contain the specified item.
     /// This instance method enables calling DoesNotContain with proper type inference.
@@ -297,6 +325,21 @@ public CollectionDoesNotContainAssertion<TCollection, TItem> DoesNotContain(
         return new CollectionDoesNotContainAssertion<TCollection, TItem>(Context, expected);
     }
 
+    /// <summary>
+    /// Asserts that the collection does not contain the specified item using a custom equality comparer.
+    /// This instance method enables calling DoesNotContain with proper type inference and a custom comparer.
+    /// Example: await Assert.That(list).DoesNotContain("value", StringComparer.OrdinalIgnoreCase);
+    /// </summary>
+    public CollectionDoesNotContainAssertion<TCollection, TItem> DoesNotContain(
+        TItem expected,
+        IEqualityComparer<TItem> comparer,
+        [CallerArgumentExpression(nameof(expected))] string? expectedExpression = null,
+        [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
+    {
+        Context.ExpressionBuilder.Append($".DoesNotContain({expectedExpression}, {comparerExpression})");
+        return new CollectionDoesNotContainAssertion<TCollection, TItem>(Context, expected, comparer);
+    }
+
     /// <summary>
     /// Asserts that the collection does not contain any item matching the predicate.
     /// This instance method enables calling DoesNotContain with proper type inference.
diff --git a/TUnit.Assertions/Sources/MemoryAssertionBase.cs b/TUnit.Assertions/Sources/MemoryAssertionBase.cs
index 20ba2d74fc..d80f5ba8d9 100644
--- a/TUnit.Assertions/Sources/MemoryAssertionBase.cs
+++ b/TUnit.Assertions/Sources/MemoryAssertionBase.cs
@@ -104,6 +104,19 @@ public MemoryContainsAssertion<TMemory, TItem> Contains(
         return new MemoryContainsAssertion<TMemory, TItem>(Context, CreateAdapter, expected);
     }
 
+    /// <summary>
+    /// Asserts that the memory contains the expected item using a custom equality comparer.
+    /// </summary>
+    public MemoryContainsAssertion<TMemory, TItem> Contains(
+        TItem expected,
+        IEqualityComparer<TItem> comparer,
+        [CallerArgumentExpression(nameof(expected))] string? expectedExpression = null,
+        [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
+    {
+        Context.ExpressionBuilder.Append($".Contains({expectedExpression}, {comparerExpression})");
+        return new MemoryContainsAssertion<TMemory, TItem>(Context, CreateAdapter, expected, comparer);
+    }
+
     /// <summary>
     /// Asserts that the memory does not contain the expected item.
     /// </summary>
@@ -115,6 +128,19 @@ public MemoryDoesNotContainAssertion<TMemory, TItem> DoesNotContain(
         return new MemoryDoesNotContainAssertion<TMemory, TItem>(Context, CreateAdapter, expected);
     }
 
+    /// <summary>
+    /// Asserts that the memory does not contain the expected item using a custom equality comparer.
+    /// </summary>
+    public MemoryDoesNotContainAssertion<TMemory, TItem> DoesNotContain(
+        TItem expected,
+        IEqualityComparer<TItem> comparer,
+        [CallerArgumentExpression(nameof(expected))] string? expectedExpression = null,
+        [CallerArgumentExpression(nameof(comparer))] string? comparerExpression = null)
+    {
+        Context.ExpressionBuilder.Append($".DoesNotContain({expectedExpression}, {comparerExpression})");
+        return new MemoryDoesNotContainAssertion<TMemory, TItem>(Context, CreateAdapter, expected, comparer);
+    }
+
     /// <summary>
     /// Gets the count for further numeric assertions.
     /// </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 becf3adaed..ee9184939c 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
@@ -1187,6 +1187,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasDistinctItemsAssertion(.<TCollection> context) { }
+        public HasDistinctItemsAssertion(.<TCollection> context, .<TItem> comparer) { }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
@@ -1901,6 +1902,7 @@ namespace .Conditions
     public class StringEqualsAssertion<TActual> : .<TActual>
     {
         public StringEqualsAssertion(.<TActual> context, string? expected) { }
+        public StringEqualsAssertion(.<TActual> context, string? expected, .<string> comparer) { }
         public StringEqualsAssertion(.<TActual> context, string? expected,  comparison) { }
         protected override .<.> CheckAsync(.<TActual> metadata) { }
         protected override string GetExpectation() { }
@@ -4819,6 +4821,7 @@ namespace .Extensions
     public static class StringEqualsAssertionExtensions
     {
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, [.("expected")] string? expectedExpression = null) { }
+        public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, .<string> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected,  comparison, [.("expected")] string? expectedExpression = null, [.("comparison")] string? comparisonExpression = null) { }
     }
     public static class StringIsEmptyAssertionExtensions
@@ -5663,6 +5666,7 @@ namespace .Sources
         public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Count() { }
         public .<TCollection, TItem> Count(<.<TItem>, .<TItem>?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
@@ -5670,6 +5674,7 @@ namespace .Sources
         public .<TCollection, TItem> Count(<.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         [("Use Count() instead, which provides all numeric assertion methods. Example: Asser" +
             "(list).Count().IsGreaterThan(5)")]
@@ -5677,6 +5682,7 @@ namespace .Sources
         [("Use Count().IsEqualTo(expectedCount) instead.")]
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
+        public .<TCollection, TItem> HasDistinctItems(.<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> HasSingleItem() { }
         public .<TCollection, TItem> HasSingleItem(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
@@ -5786,9 +5792,11 @@ namespace .Sources
         public .<TMemory, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TMemory, TItem> Count() { }
         protected abstract .<TItem> CreateAdapter(TMemory value);
         public .<TMemory, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
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 d3c4bae057..603dcf51d2 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
@@ -1170,6 +1170,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasDistinctItemsAssertion(.<TCollection> context) { }
+        public HasDistinctItemsAssertion(.<TCollection> context, .<TItem> comparer) { }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
@@ -1884,6 +1885,7 @@ namespace .Conditions
     public class StringEqualsAssertion<TActual> : .<TActual>
     {
         public StringEqualsAssertion(.<TActual> context, string? expected) { }
+        public StringEqualsAssertion(.<TActual> context, string? expected, .<string> comparer) { }
         public StringEqualsAssertion(.<TActual> context, string? expected,  comparison) { }
         protected override .<.> CheckAsync(.<TActual> metadata) { }
         protected override string GetExpectation() { }
@@ -4769,6 +4771,7 @@ namespace .Extensions
     public static class StringEqualsAssertionExtensions
     {
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, [.("expected")] string? expectedExpression = null) { }
+        public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, .<string> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected,  comparison, [.("expected")] string? expectedExpression = null, [.("comparison")] string? comparisonExpression = null) { }
     }
     public static class StringIsEmptyAssertionExtensions
@@ -5611,12 +5614,14 @@ namespace .Sources
         public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Count() { }
         public .<TCollection, TItem> Count(<.<TItem>, .<TItem>?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
         public .<TCollection, TItem> Count(<.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         [("Use Count() instead, which provides all numeric assertion methods. Example: Asser" +
             "(list).Count().IsGreaterThan(5)")]
@@ -5624,6 +5629,7 @@ namespace .Sources
         [("Use Count().IsEqualTo(expectedCount) instead.")]
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
+        public .<TCollection, TItem> HasDistinctItems(.<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> HasSingleItem() { }
         public .<TCollection, TItem> HasSingleItem(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
@@ -5733,9 +5739,11 @@ namespace .Sources
         public .<TMemory, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TMemory, TItem> Count() { }
         protected abstract .<TItem> CreateAdapter(TMemory value);
         public .<TMemory, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
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 a47687f281..8e6a186e7d 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
@@ -1187,6 +1187,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasDistinctItemsAssertion(.<TCollection> context) { }
+        public HasDistinctItemsAssertion(.<TCollection> context, .<TItem> comparer) { }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
@@ -1901,6 +1902,7 @@ namespace .Conditions
     public class StringEqualsAssertion<TActual> : .<TActual>
     {
         public StringEqualsAssertion(.<TActual> context, string? expected) { }
+        public StringEqualsAssertion(.<TActual> context, string? expected, .<string> comparer) { }
         public StringEqualsAssertion(.<TActual> context, string? expected,  comparison) { }
         protected override .<.> CheckAsync(.<TActual> metadata) { }
         protected override string GetExpectation() { }
@@ -4819,6 +4821,7 @@ namespace .Extensions
     public static class StringEqualsAssertionExtensions
     {
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, [.("expected")] string? expectedExpression = null) { }
+        public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, .<string> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected,  comparison, [.("expected")] string? expectedExpression = null, [.("comparison")] string? comparisonExpression = null) { }
     }
     public static class StringIsEmptyAssertionExtensions
@@ -5663,6 +5666,7 @@ namespace .Sources
         public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Count() { }
         public .<TCollection, TItem> Count(<.<TItem>, .<TItem>?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
@@ -5670,6 +5674,7 @@ namespace .Sources
         public .<TCollection, TItem> Count(<.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         [("Use Count() instead, which provides all numeric assertion methods. Example: Asser" +
             "(list).Count().IsGreaterThan(5)")]
@@ -5677,6 +5682,7 @@ namespace .Sources
         [("Use Count().IsEqualTo(expectedCount) instead.")]
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
+        public .<TCollection, TItem> HasDistinctItems(.<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> HasSingleItem() { }
         public .<TCollection, TItem> HasSingleItem(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
@@ -5786,9 +5792,11 @@ namespace .Sources
         public .<TMemory, TItem> All(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TMemory, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TMemory, TItem> Count() { }
         protected abstract .<TItem> CreateAdapter(TMemory value);
         public .<TMemory, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TMemory, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         public .<TMemory, TItem> HasDistinctItems() { }
         public .<TMemory, TItem> HasSingleItem() { }
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 a1fe4b0503..dc633b5be8 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
@@ -1019,6 +1019,7 @@ namespace .Conditions
         where TCollection : .<TItem>
     {
         public HasDistinctItemsAssertion(.<TCollection> context) { }
+        public HasDistinctItemsAssertion(.<TCollection> context, .<TItem> comparer) { }
         protected override .<.> CheckAsync(.<TCollection> metadata) { }
         protected override string GetExpectation() { }
     }
@@ -1687,6 +1688,7 @@ namespace .Conditions
     public class StringEqualsAssertion<TActual> : .<TActual>
     {
         public StringEqualsAssertion(.<TActual> context, string? expected) { }
+        public StringEqualsAssertion(.<TActual> context, string? expected, .<string> comparer) { }
         public StringEqualsAssertion(.<TActual> context, string? expected,  comparison) { }
         protected override .<.> CheckAsync(.<TActual> metadata) { }
         protected override string GetExpectation() { }
@@ -4194,6 +4196,7 @@ namespace .Extensions
     public static class StringEqualsAssertionExtensions
     {
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, [.("expected")] string? expectedExpression = null) { }
+        public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected, .<string> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public static .<TActual> IsEqualTo<TActual>(this .<TActual> source, string? expected,  comparison, [.("expected")] string? expectedExpression = null, [.("comparison")] string? comparisonExpression = null) { }
     }
     public static class StringIsEmptyAssertionExtensions
@@ -4949,12 +4952,14 @@ namespace .Sources
         public .<TCollection, TItem> Any(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Contains(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> Contains(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> ContainsOnly(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> Count() { }
         public .<TCollection, TItem> Count(<.<TItem>, .<TItem>?> itemAssertion, [.("itemAssertion")] string? expression = null) { }
         public .<TCollection, TItem> Count(<.<int>, .<int>?> countAssertion, [.("countAssertion")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TCollection, TItem> DoesNotContain(TItem expected, [.("expected")] string? expression = null) { }
+        public .<TCollection, TItem> DoesNotContain(TItem expected, .<TItem> comparer, [.("expected")] string? expectedExpression = null, [.("comparer")] string? comparerExpression = null) { }
         protected override string GetExpectation() { }
         [("Use Count() instead, which provides all numeric assertion methods. Example: Asser" +
             "(list).Count().IsGreaterThan(5)")]
@@ -4962,6 +4967,7 @@ namespace .Sources
         [("Use Count().IsEqualTo(expectedCount) instead.")]
         public .<TCollection, TItem> HasCount(int expectedCount, [.("expectedCount")] string? expression = null) { }
         public .<TCollection, TItem> HasDistinctItems() { }
+        public .<TCollection, TItem> HasDistinctItems(.<TItem> comparer, [.("comparer")] string? comparerExpression = null) { }
         public .<TCollection, TItem> HasSingleItem() { }
         public .<TCollection, TItem> HasSingleItem(<TItem, bool> predicate, [.("predicate")] string? expression = null) { }
         public .<TTarget, TCollection> IsAssignableTo<TTarget>() { }
diff --git a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.Net4_7.verified.txt b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.Net4_7.verified.txt
index f1106c74fd..8386373c06 100644
--- a/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.Net4_7.verified.txt
+++ b/TUnit.PublicAPI/Tests.Core_Library_Has_No_API_Changes.Net4_7.verified.txt
@@ -511,6 +511,13 @@ namespace
         public static readonly .DefaultExecutor Instance;
         protected override . ExecuteAsync(<.> action) { }
     }
+    public static class Defaults
+    {
+        public static readonly  ForcefulExitTimeout;
+        public static readonly  HookTimeout;
+        public static readonly  ProcessExitHookDelay;
+        public static readonly  TestTimeout;
+    }
     public abstract class DependencyInjectionDataSourceAttribute<TScope> : .UntypedDataSourceGeneratorAttribute
     {
         protected DependencyInjectionDataSourceAttribute() { }
@@ -562,6 +569,7 @@ namespace
         public void SetDisplayName(string displayName) { }
         public void SetDisplayNameFormatter( formatterType) { }
         public void SetPriority(. priority) { }
+        public void SetRetryBackoff(int backoffMs, double backoffMultiplier) { }
         public void SetRetryLimit(int retryLimit) { }
         public void SetRetryLimit(int retryCount, <.TestContext, , int, .<bool>> shouldRetry) { }
     }
@@ -1138,7 +1146,10 @@ namespace
     public class RetryAttribute : .TUnitAttribute, .IScopedAttribute, ., .
     {
         public RetryAttribute(int times) { }
+        public int BackoffMs { get; set; }
+        public double BackoffMultiplier { get; set; }
         public int Order { get; }
+        public []? RetryOnExceptionTypes { get; set; }
         public  ScopeType { get; }
         public int Times { get; }
         public . OnTestDiscovered(.DiscoveredTestContext context) { }
@@ -1407,6 +1418,8 @@ namespace
         public [] MethodGenericArguments { get; set; }
         public required .MethodMetadata MethodMetadata { get; set; }
         public required string MethodName { get; init; }
+        public int RetryBackoffMs { get; set; }
+        public double RetryBackoffMultiplier { get; set; }
         public int RetryLimit { get; set; }
         public required  ReturnType { get; set; }
         public required object?[] TestClassArguments { get; set; }
@@ -2359,6 +2372,8 @@ namespace .Interfaces
     }
     public interface ITestConfiguration
     {
+        int RetryBackoffMs { get; }
+        double RetryBackoffMultiplier { get; }
         int RetryLimit { get; }
         ? Timeout { get; }
     }