add some test gaps

Author: AnakinRaW

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/FileExistsStrategyTestBase.cs

@@ -209,6 +209,18 @@ public void FileExists_PathResolvesToDirectory_ReturnsFalse(string input)
         Assert.False(exists);
     }
 
+    [Fact]
+    public void FileExists_EmptyRelativePath_ReturnsFalse()
+    {
+        // After joining "" with the base directory, the dispatcher hands the strategy the bare
+        // base directory. Every strategy must treat that as not-a-file rather than reporting the
+        // directory itself as existing.
+        var dir = NewTempDir();
+        FileSystem.File.WriteAllText(FileSystem.Path.Combine(dir, "x.txt"), "x");
+
+        Assert.False(FileExists(string.Empty.AsSpan(), dir.AsSpan()));
+    }
+
     [Theory]
     [InlineData("test.txt", "TEST.txt")]
     [InlineData("dir/test.txt", "DIR/TEST.txt")]

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/FileExistStrategies/VirtualDirectoryTests.cs

@@ -0,0 +1,20 @@
+using System.Collections.Generic;
+using PG.StarWarsGame.Engine.IO.FileExistStrategies;
+using Xunit;
+
+namespace PG.StarWarsGame.Engine.FileSystem.Test.IO.FileExistStrategies;
+
+public class VirtualDirectoryTests
+{
+    [Fact]
+    public void Ctor_ExposesAssignedFields()
+    {
+        var files = new Dictionary<string, string> { ["foo.xml"] = "FOO.xml" };
+
+        var dir = new VirtualDirectory("/some/dir", files);
+
+        Assert.Equal("/some/dir", dir.OnDiskPath);
+        Assert.Same(files, dir.Files);
+        Assert.Equal("FOO.xml", dir.Files["foo.xml"]);
+    }
+}

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/PetroglyphFileSystemTests.CombineJoin.cs

@@ -1,8 +1,10 @@
 using System;
 using System.IO;
-using AnakinRaW.CommonUtilities.FileSystem;
 using PG.StarWarsGame.Engine.Utilities;
 using Xunit;
+#if NETFRAMEWORK
+using AnakinRaW.CommonUtilities.FileSystem;
+#endif
 
 namespace PG.StarWarsGame.Engine.FileSystem.Test.IO;
 
@@ -86,4 +88,32 @@ public void JoinPath(string path1, string path2, string expected)
             vsb.Dispose();
         }
     }
+
+    [Fact]
+    public void CombinePath_FirstArgNull_Throws()
+    {
+        Assert.Throws<ArgumentNullException>(() => _pgFileSystem.CombinePath(null!, "b"));
+    }
+
+    [Fact]
+    public void CombinePath_SecondArgNull_Throws()
+    {
+        Assert.Throws<ArgumentNullException>(() => _pgFileSystem.CombinePath("a", null!));
+    }
+
+    [Fact]
+    public void JoinPath_BothEmpty_LeavesBufferUntouched()
+    {
+        var vsb = new ValueStringBuilder();
+        try
+        {
+            vsb.Append("preexisting");
+            _pgFileSystem.JoinPath(ReadOnlySpan<char>.Empty, ReadOnlySpan<char>.Empty, ref vsb);
+            Assert.Equal("preexisting", vsb.ToString());
+        }
+        finally
+        {
+            vsb.Dispose();
+        }
+    }
 }

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/PetroglyphFileSystemTests.Exist.cs

@@ -8,13 +8,21 @@ public partial class PetroglyphFileSystemTests
     [Theory]
 #if Windows
     [InlineData("C:\\test.txt", true)]
+    [InlineData("C:/test.txt", true)]
+    [InlineData("D:\\path\\to\\file", true)]
     [InlineData("/test.txt", false)]
     [InlineData("\\test.txt", false)]
 #else
     [InlineData("/test.txt", true)]
+    [InlineData("/", true)]
+    [InlineData("/a/b/c", true)]
+    [InlineData("\\test.txt", false)]
     [InlineData("C:\\test.txt", false)]
 #endif
     [InlineData("test.txt", false)]
+    [InlineData("a/b/c", false)]
+    [InlineData("./file.txt", false)]
+    [InlineData("../file.txt", false)]
     [InlineData("", false)]
     public void IsPathFullyQualified_Exists(string path, bool expected)
     {

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/PetroglyphFileSystemTests.PathEqual.cs

@@ -9,6 +9,13 @@ public partial class PetroglyphFileSystemTests
     [InlineData("dir/file.txt", "DIR\\FILE.TXT", true)]
     [InlineData("dir/file.txt", "dir/other.txt", false)]
     [InlineData("a/b/c", "a\\b\\c", true)]
+    [InlineData("a/b/c", "a/b/c", true)]
+    [InlineData("a/b/c", "A/B/C", true)]
+    [InlineData("a/b/c", "a/b/c/d", false)]
+    [InlineData("a/b/c/d", "a/b/c", false)]
+    [InlineData("Mods/Test/Data/foo.xml", "MODS\\TEST\\DATA\\FOO.XML", true)]
+    [InlineData("a//b", "a\\b", true)]
+    [InlineData("a/b/", "a\\b\\", true)]
     public void PathsAreEqual(string pathA, string pathB, bool expected)
     {
         Assert.Equal(expected, _pgFileSystem.PathsAreEqual(pathA, pathB));

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/IO/PetroglyphFileSystemTests.cs

@@ -39,8 +39,47 @@ public void UnderlyingFileSystem_ReturnsCorrectInstance()
     [InlineData("dir/file.txt", false)]
     [InlineData("file.txt", false)]
     [InlineData("", false)]
+    [InlineData("/", true)]
+    [InlineData("\\", true)]
+    [InlineData("a", false)]
+    [InlineData(".", false)]
+    [InlineData("..", false)]
+    [InlineData("dir//", true)]
+    [InlineData("dir\\\\", true)]
     public void HasTrailingDirectorySeparator(string path, bool expected)
     {
         Assert.Equal(expected, _pgFileSystem.HasTrailingDirectorySeparator(path.AsSpan()));
     }
+
+    [Fact]
+    public void OpenRead_ExistingFile_ReturnsReadableStream()
+    {
+        var dir = _fileSystem.Path.Combine(_fileSystem.Path.GetTempPath(), Guid.NewGuid().ToString());
+        _fileSystem.Directory.CreateDirectory(dir);
+        try
+        {
+            var file = _fileSystem.Path.Combine(dir, "openread.bin");
+            _fileSystem.File.WriteAllBytes(file, new byte[] { 1, 2, 3, 4 });
+
+            using var stream = _pgFileSystem.OpenRead(file);
+
+            Assert.True(stream.CanRead);
+            Assert.False(stream.CanWrite);
+            Assert.Equal(4, stream.Length);
+            var buf = new byte[4];
+            Assert.Equal(4, stream.Read(buf, 0, 4));
+            Assert.Equal(new byte[] { 1, 2, 3, 4 }, buf);
+        }
+        finally
+        {
+            _fileSystem.Directory.Delete(dir, recursive: true);
+        }
+    }
+
+    [Fact]
+    public void OpenRead_MissingFile_Throws()
+    {
+        var missing = _fileSystem.Path.Combine(_fileSystem.Path.GetTempPath(), Guid.NewGuid() + ".missing");
+        Assert.ThrowsAny<System.IO.IOException>(() => _pgFileSystem.OpenRead(missing));
+    }
 }

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem.Test/Utilities/LowLevelPathTests.cs

@@ -37,4 +37,33 @@ public void GetCommonDirectoryPrefixLength_CaseInsensitive_Windows(string path,
     {
         Assert.Equal(expected, LowLevelPath.GetCommonDirectoryPrefixLength(path.AsSpan(), directory.AsSpan()));
     }
+    
+    [PlatformSpecificFact(TestPlatformIdentifier.Windows)]
+    public void IsHostFileSystemCaseSensitive_Windows_IsFalse()
+    {
+        Assert.False(LowLevelPath.IsHostFileSystemCaseSensitive);
+    }
+
+    [PlatformSpecificFact(TestPlatformIdentifier.Linux)]
+    public void IsHostFileSystemCaseSensitive_Linux_IsTrue()
+    {
+        Assert.True(LowLevelPath.IsHostFileSystemCaseSensitive);
+    }
+
+    [Theory]
+    // Sibling at root level: path and directory diverge before any separator → no shared prefix.
+    [InlineData("foo/bar", "baz/qux", 0)]
+    // Trailing separator on path side, directory does not have one — must match the no-trailing form.
+    [InlineData("a/b/", "a/b", 3)]
+    [InlineData("a/b", "a/b/", 3)]
+    // Sibling whose name is a prefix of the other — shared prefix is the parent dir, not the
+    // longest character match. "a/b" vs "a/ba" must NOT be reported as 3 chars in common.
+    [InlineData("a/b", "a/ba", 2)]
+    [InlineData("a/ba", "a/b", 2)]
+    [InlineData("a/foo", "a/foobar", 2)]
+    [InlineData("a/foobar", "a/foo", 2)]
+    public void GetCommonDirectoryPrefixLength_BoundaryCases(string path, string directory, int expected)
+    {
+        Assert.Equal(expected, LowLevelPath.GetCommonDirectoryPrefixLength(path.AsSpan(), directory.AsSpan()));
+    }
 }

src/PetroglyphTools/PG.StarWarsGame.Engine.FileSystem/Utilities/LowLevelPath.cs

@@ -41,8 +41,8 @@ public static int GetCommonDirectoryPrefixLength(ReadOnlySpan<char> path, ReadOn
         if (i == minLen)
         {
             if (path.Length == directory.Length
-                || i == directory.Length && IsDirectorySeparator(path[i])
-                || i == path.Length && IsDirectorySeparator(directory[i]))
+                || (i == directory.Length && IsDirectorySeparator(path[i]))
+                || (i == path.Length && IsDirectorySeparator(directory[i])))
                 return i;
         }