Allow IEqualityComparer in string (Not)BeEquivalentTo assertion

Src/FluentAssertions/Common/StringExtensions.cs

@@ -25,30 +25,6 @@ public static int IndexOfFirstMismatch(this string value, string expected, IEqua
         return -1;
     }
 
-    /// <summary>
-    /// Finds the first index at which the <paramref name="value"/> does not match the <paramref name="expected"/>
-    /// string anymore, accounting for the specified <paramref name="stringComparison"/>.
-    /// </summary>
-    public static int IndexOfFirstMismatch(this string value, string expected, StringComparison stringComparison)
-    {
-        Func<char, char, bool> comparer = GetCharComparer(stringComparison);
-
-        for (int index = 0; index < value.Length; index++)
-        {
-            if (index >= expected.Length || !comparer(value[index], expected[index]))
-            {
-                return index;
-            }
-        }
-
-        return -1;
-    }
-
-    private static Func<char, char, bool> GetCharComparer(StringComparison stringComparison) =>
-        stringComparison == StringComparison.Ordinal
-            ? (x, y) => x == y
-            : (x, y) => char.ToUpperInvariant(x) == char.ToUpperInvariant(y);
-
     /// <summary>
     /// Gets the quoted three characters at the specified index of a string, including the index itself.
     /// </summary>

Src/FluentAssertions/Primitives/StringAssertions.cs

@@ -704,7 +704,7 @@ public AndConstraint<TAssertions> StartWith(string expected, string because = ""
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare start of string with <null>.");
 
         var stringStartValidator = new StringValidator(
-            new StringStartStrategy(StringComparison.Ordinal),
+            new StringStartStrategy(StringComparer.Ordinal),
             because, becauseArgs);
 
         stringStartValidator.Validate(Subject, expected);
@@ -757,7 +757,7 @@ public AndConstraint<TAssertions> NotStartWith(string unexpected, string because
         Guard.ThrowIfArgumentIsNull(expected, nameof(expected), "Cannot compare string start equivalence with <null>.");
 
         var stringStartValidator = new StringValidator(
-            new StringStartStrategy(StringComparison.OrdinalIgnoreCase),
+            new StringStartStrategy(StringComparer.OrdinalIgnoreCase),
             because, becauseArgs);
 
         stringStartValidator.Validate(Subject, expected);

Src/FluentAssertions/Primitives/StringStartStrategy.cs

@@ -1,30 +1,29 @@
-using System;
+using System.Collections.Generic;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
 
 namespace FluentAssertions.Primitives;
 
 internal class StringStartStrategy : IStringComparisonStrategy
 {
-    private readonly StringComparison stringComparison;
+    private readonly IEqualityComparer<string> comparer;
+    private readonly bool ignoringCase;
 
-    public StringStartStrategy(StringComparison stringComparison)
+    public StringStartStrategy(IEqualityComparer<string> comparer)
     {
-        this.stringComparison = stringComparison;
+        this.comparer = comparer;
+        ignoringCase = comparer.Equals("A", "a");
     }
 
     public string ExpectationDescription
     {
         get
         {
-            string predicateDescription = IgnoreCase ? "start with equivalent of" : "start with";
+            string predicateDescription = ignoringCase ? "start with equivalent of" : "start with";
             return "Expected {context:string} to " + predicateDescription + " ";
         }
     }
 
-    private bool IgnoreCase
-        => stringComparison == StringComparison.OrdinalIgnoreCase;
-
     public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, string expected)
     {
         if (!assertion
@@ -34,13 +33,13 @@ public void ValidateAgainstMismatch(IAssertionScope assertion, string subject, s
             return;
         }
 
-        if (subject.StartsWith(expected, stringComparison))
+        int indexOfMismatch = subject.IndexOfFirstMismatch(expected, comparer);
+
+        if (indexOfMismatch < 0 || indexOfMismatch >= expected.Length)
         {
             return;
         }
 
-        int indexOfMismatch = subject.IndexOfFirstMismatch(expected, stringComparison);
-
         assertion.FailWith(
             ExpectationDescription + "{0}{reason}, but {1} differs near " + subject.IndexedSegmentAt(indexOfMismatch) +
             ".",

Tests/FluentAssertions.Specs/Primitives/StringAssertionSpecs.StartWith.cs

@@ -26,6 +26,20 @@ public void When_asserting_string_starts_with_the_same_value_it_should_not_throw
             action.Should().NotThrow();
         }
 
+        [Fact]
+        public void When_expected_string_is_the_same_value_it_should_not_throw()
+        {
+            // Arrange
+            string value = "ABC";
+
+            // Act
+            Action action = () =>
+                value.Should().StartWith(value);
+
+            // Assert
+            action.Should().NotThrow();
+        }
+
         [Fact]
         public void When_string_does_not_start_with_expected_phrase_it_should_throw()
         {