Align path prefix checks with platform case sensitivity

CHANGELOG.md

@@ -17,6 +17,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - `LocalPath.IsPrefixOf` now treats an empty path — the normalized form of `""`, `"."` and `"a/.."`, and the parent of any single-segment relative path — as the current directory, so it is a prefix of every relative path that does not begin with a `..` reference.
 
 ### Fixed
+- [#225](https://github.com/ForNeVeR/TruePath/issues/225): Make path prefix checks use the same platform-default case sensitivity as path equality.
 - `LocalPath.IsPrefixOf` and `StartsWith` now compare path strings ordinally. Previously they used the current culture, which ignores collation-ignorable characters, so a path could be reported as a prefix of an unrelated one.
 
 ## [1.12.0] - 2026-03-14

TruePath.Tests/AbsolutePathTests.cs

@@ -144,7 +144,6 @@ public void ParentIsCalculatedCorrectly(string relativePath, string? expectedRel
 
     [Theory]
     [InlineData("/home/user", "/home/user/documents", true)]
-    [InlineData("/home/usEr", "/home/User/documents", false)]
     [InlineData("/home/user/documents", "/home/user/documents", true)]
     [InlineData("/home/user/documents", "/home/user", false)]
     public void IsPrefixOfShouldBeEquivalentToStartsWith(string pathA, string pathB, bool expected)
@@ -158,6 +157,40 @@ public void IsPrefixOfShouldBeEquivalentToStartsWith(string pathA, string pathB,
         Assert.Equal(expected, b.StartsWith(a));
     }
 
+    [Fact]
+    public void IsPrefixOfFollowsPlatformCaseSensitivityForSameName()
+    {
+        var root = new AbsolutePath(OperatingSystem.IsWindows() ? @"A:\" : "/");
+        var a = root / "Foo";
+        var b = root / "foo";
+
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), a.IsPrefixOf(b));
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), b.StartsWith(a));
+        Assert.Equal(a == b, a.IsPrefixOf(b));
+    }
+
+    [Fact]
+    public void IsPrefixOfFollowsPlatformCaseSensitivityForDescendant()
+    {
+        var root = new AbsolutePath(OperatingSystem.IsWindows() ? @"A:\" : "/");
+        var a = root / "Foo";
+        var b = root / "foo/file.txt";
+
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), a.IsPrefixOf(b));
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), b.StartsWith(a));
+    }
+
+    [Fact]
+    public void IsPrefixOfRequiresWholeSegmentRegardlessOfCase()
+    {
+        var root = new AbsolutePath(OperatingSystem.IsWindows() ? @"A:\" : "/");
+        var a = root / "Foo";
+        var b = root / "foobar";
+
+        Assert.False(a.IsPrefixOf(b));
+        Assert.False(b.StartsWith(a));
+    }
+
     [Theory]
     [InlineData("sub", "sub/a.txt", true)]
     [InlineData("sub", "sub", true)]

TruePath.Tests/LocalPathTests.cs

@@ -70,7 +70,7 @@ public void IsPrefixOfShouldBeEquivalentToStartsWith(string pathA, string pathB)
 
         // Act
         var isPrefix = a.IsPrefixOf(b);
-        var startsWith = b.Value.StartsWith(a.Value);
+        var startsWith = b.StartsWith(a);
 
         // Assert
         Assert.Equal(isPrefix, startsWith);
@@ -115,6 +115,37 @@ public void IsPrefixOfAndStartsWith(string prefix, string other, bool result)
         Assert.Equal(result, b.StartsWith(a));
     }
 
+    [Fact]
+    public void IsPrefixOfFollowsPlatformCaseSensitivityForSameName()
+    {
+        var a = new LocalPath("Foo");
+        var b = new LocalPath("foo");
+
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), a.IsPrefixOf(b));
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), b.StartsWith(a));
+        Assert.Equal(a == b, a.IsPrefixOf(b));
+    }
+
+    [Fact]
+    public void IsPrefixOfFollowsPlatformCaseSensitivityForDescendant()
+    {
+        var a = new LocalPath("Foo");
+        var b = new LocalPath("foo/bar");
+
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), a.IsPrefixOf(b));
+        Assert.Equal(Utils.IsPlatformCaseInsensitive(), b.StartsWith(a));
+    }
+
+    [Fact]
+    public void IsPrefixOfRequiresWholeSegmentRegardlessOfCase()
+    {
+        var a = new LocalPath("Foo");
+        var b = new LocalPath("foobar");
+
+        Assert.False(a.IsPrefixOf(b));
+        Assert.False(b.StartsWith(a));
+    }
+
     [Fact]
     public void EmptyParentIsPrefixOfDescendantPath()
     {

TruePath.Tests/Utils.cs

@@ -23,6 +23,9 @@ internal static string ToNonCanonicalCase(this string path)
         return nonCanonicalPath;
     }
 
+    internal static bool IsPlatformCaseInsensitive() =>
+        OperatingSystem.IsWindows() || OperatingSystem.IsMacOS();
+
     internal static bool RunsOnCi()
     {
         return Environment.GetEnvironmentVariable("CI") is not null;

TruePath/AbsolutePath.cs

@@ -137,7 +137,7 @@ public static AbsolutePath CurrentWorkingDirectory
     public override string ToString() => Value;
 
     /// <summary>Compares the path with another.</summary>
-    /// <remarks>Note that currently this comparison is case-sensitive.</remarks>
+    /// <remarks>Uses <see cref="PlatformDefaultComparer"/> for platform-default case sensitivity.</remarks>
     public bool Equals(AbsolutePath other) => Equals(other, PlatformDefaultComparer);
 
     /// <summary>

TruePath/Comparers/PlatformDefaultPathComparer.cs

@@ -21,19 +21,14 @@ namespace TruePath.Comparers;
 /// </remarks>
 internal class PlatformDefaultPathComparer<TPath> : IPathComparer<TPath> where TPath : IPath
 {
-    private readonly StringComparer _stringComparer;
+    internal static readonly StringComparison DefaultStringComparison =
+        RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX)
+            ? StringComparison.OrdinalIgnoreCase
+            : StringComparison.Ordinal;
 
-    public PlatformDefaultPathComparer()
-    {
-        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-        {
-            _stringComparer = StringComparer.OrdinalIgnoreCase;
-        }
-        else
-        {
-            _stringComparer = StringComparer.Ordinal;
-        }
-    }
+    private readonly StringComparer _stringComparer = DefaultStringComparison == StringComparison.OrdinalIgnoreCase
+        ? StringComparer.OrdinalIgnoreCase
+        : StringComparer.Ordinal;
 
     public bool Equals(TPath? x, TPath? y)
     {

TruePath/IPath.cs

@@ -49,7 +49,7 @@ public interface IPath<TPath> where TPath : IPath<TPath>
     /// This is the exact inverse of <see cref="StartsWith"/>: <c>a.IsPrefixOf(b)</c> means the same as
     /// <c>b.StartsWith(a)</c>.
     /// </remarks>
-    /// <remarks>Note that currently this comparison is case-sensitive.</remarks>
+    /// <remarks>Case sensitivity follows the path type's platform-default comparer.</remarks>
     bool IsPrefixOf(TPath other);
 
     /// <summary>
@@ -68,7 +68,7 @@ public interface IPath<TPath> where TPath : IPath<TPath>
     /// This is the exact inverse of <see cref="IsPrefixOf"/>: <c>a.StartsWith(b)</c> means the same as
     /// <c>b.IsPrefixOf(a)</c>.
     /// </remarks>
-    /// <remarks>Note that currently this comparison is case-sensitive.</remarks>
+    /// <remarks>Case sensitivity follows the path type's platform-default comparer.</remarks>
     bool StartsWith(TPath other);
 
 #if NET8_0_OR_GREATER

TruePath/LocalPath.cs

@@ -88,7 +88,7 @@ public LocalPath? Parent
     public override string ToString() => Value;
 
     /// <summary>Compares the path with another.</summary>
-    /// <remarks>Note that currently this comparison is case-sensitive.</remarks>
+    /// <remarks>Uses <see cref="PlatformDefaultComparer"/> for platform-default case sensitivity.</remarks>
     public bool Equals(LocalPath other) => Equals(other, PlatformDefaultComparer);
 
     /// <summary>
@@ -165,9 +165,8 @@ public bool IsPrefixOf(LocalPath other)
         // very start of a path, so testing the first segment is enough.
         if (Value.Length == 0) return !StartsWithParentDirectoryReference(other.Value);
 
-        // TODO[#225]: this comparison is ordinal, while Equals follows the platform default, so on Windows and macOS
-        // two paths may be equal and yet not prefixes of each other.
-        if (!(Value.Length <= other.Value.Length && other.Value.StartsWith(Value, StringComparison.Ordinal)))
+        if (!(Value.Length <= other.Value.Length &&
+              other.Value.StartsWith(Value, PlatformDefaultPathComparer<LocalPath>.DefaultStringComparison)))
             return false;
         return other.Value.Length == Value.Length ||
                Value[Value.Length - 1] == Separator ||