Platform Independent Filenames

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/HolderTest_MegAndDisposableModel.cs

@@ -3,31 +3,31 @@
 
 namespace PG.StarWarsGame.Files.Test;
 
-public class HolderTest_MegAndDisposableModel : PetroglyphFileHolderTest<DisposableModel, MegTestParam, TestFileHolder<DisposableModel, MegTestParam>>
+public class HolderTest_MegAndDisposableModel : PetroglyphFileHolderTest<DisposableModel, TestMegFileInfo, TestFileHolder<DisposableModel, TestMegFileInfo>>
 {
     protected override DisposableModel CreateModel()
     {
         return new DisposableModel();
     }
 
-    protected override MegTestParam CreateFileInfo(string path, bool inMeg = false)
+    protected override TestMegFileInfo CreateFileInfo(string path, bool inMeg = false)
     {
-        return new MegTestParam { FilePath = path, IsInsideMeg = inMeg};
+        return new TestMegFileInfo { FilePath = path, IsInsideMeg = inMeg};
     }
 
-    protected override TestFileHolder<DisposableModel, MegTestParam> CreateFileHolder(DisposableModel model, MegTestParam fileInfo)
+    protected override TestFileHolder<DisposableModel, TestMegFileInfo> CreateFileHolder(DisposableModel model, TestMegFileInfo fileInfo)
     {
-        return new TestFileHolder<DisposableModel, MegTestParam>(model, fileInfo, ServiceProvider);
+        return new TestFileHolder<DisposableModel, TestMegFileInfo>(model, fileInfo, ServiceProvider);
     }
 
     [Fact]
     public void Ctor_ThrowsArgumentNullException()
     {
         var model = CreateModel();
         var fileInfo = CreateFileInfo(DefaultFileName);
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, MegTestParam>(model, fileInfo, null!));
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, MegTestParam>(model, null!, ServiceProvider));
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, MegTestParam>(null!, fileInfo, ServiceProvider));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, TestMegFileInfo>(model, fileInfo, null!));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, TestMegFileInfo>(model, null!, ServiceProvider));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<DisposableModel, TestMegFileInfo>(null!, fileInfo, ServiceProvider));
     }
 
     [Fact]

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/HolderTest_NonMegNonDisposableModel.cs

@@ -3,32 +3,32 @@
 
 namespace PG.StarWarsGame.Files.Test;
 
-public class HolderTest_NonMegNonDisposableModel : PetroglyphFileHolderTest<object, TestParam, TestFileHolder<object, TestParam>>
+public class HolderTest_NonMegNonDisposableModel : PetroglyphFileHolderTest<object, TestFileInfo, TestFileHolder<object, TestFileInfo>>
 {
     protected override object CreateModel()
     {
         return new DisposableModel();
     }
 
-    protected override TestParam CreateFileInfo(string path, bool inMeg = false)
+    protected override TestFileInfo CreateFileInfo(string path, bool inMeg = false)
     {
         if (inMeg) 
             Assert.Fail();
-        return new TestParam { FilePath = path };
+        return new TestFileInfo { FilePath = path };
     }
 
-    protected override TestFileHolder<object, TestParam> CreateFileHolder(object model, TestParam fileInfo)
+    protected override TestFileHolder<object, TestFileInfo> CreateFileHolder(object model, TestFileInfo fileInfo)
     {
-        return new TestFileHolder<object, TestParam>(model, fileInfo, ServiceProvider);
+        return new TestFileHolder<object, TestFileInfo>(model, fileInfo, ServiceProvider);
     }
 
     [Fact]
     public void Ctor_ThrowsArgumentNullException()
     {
         var model = CreateModel();
         var fileInfo = CreateFileInfo(DefaultFileName);
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestParam>(model, fileInfo, null!));
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestParam>(model, null!, ServiceProvider));
-        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestParam>(null!, fileInfo, ServiceProvider));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestFileInfo>(model, fileInfo, null!));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestFileInfo>(model, null!, ServiceProvider));
+        Assert.Throws<ArgumentNullException>(() => new TestFileHolder<object, TestFileInfo>(null!, fileInfo, ServiceProvider));
     }
 }

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/PetroglyphFileHolderTest.cs

@@ -1,6 +1,7 @@
-using PG.Testing;
+using PG.Testing;
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 using AnakinRaW.CommonUtilities.Testing.Attributes;
 using AnakinRaW.CommonUtilities.Testing.Extensions;
 using Testably.Abstractions.Testing;
@@ -21,72 +22,81 @@ public abstract class PetroglyphFileHolderTest<TModel, TFileInfo, THolder> : PGT
 
     protected abstract THolder CreateFileHolder(TModel model, TFileInfo fileInfo);
 
-
-    [Fact]
-    public void Ctor_SetupProperties()
+    [Theory]
+    [InlineData("test.txt")]
+    [InlineData("./test")]
+    [InlineData("a/../test")]
+    [InlineData("üöä")]
+    [InlineData("a/b")]
+    public void Ctor_LocalFile_SetupProperties(string filePath)
     {
         var model = CreateModel();
-
-        FileSystem.Initialize().WithFile(DefaultFileName);
-        var param = CreateFileInfo(DefaultFileName);
+        FileSystem.Initialize().WithFile(filePath);
+        var param = CreateFileInfo(filePath);
 
         var holder = CreateFileHolder(model, param);
 
+        var expectedFilePath = FileSystem.Path.GetFullPath(filePath);
+
         Assert.Same(model, holder.Content);
         Assert.Same(model, ((IPetroglyphFileHolder)holder).Content);
+        Assert.Same(ServiceProvider, holder.Services);
+        Assert.NotNull(holder.Logger);
+
+        Assert.Equal(FileSystem.Path.GetFileName(expectedFilePath), holder.FileName);
+        Assert.Equal(expectedFilePath, holder.FilePath);
+        Assert.Equal(FileSystem.Path.GetDirectoryName(expectedFilePath), holder.Directory);
+
+        Assert.Equal(expectedFilePath, holder.FileInformation.FilePath);
         Assert.NotSame(param, holder.FileInformation);
         Assert.NotSame(param, ((IPetroglyphFileHolder)holder).FileInformation);
-        Assert.Equal(FileSystem.Path.GetFullPath(param.FilePath), FileSystem.Path.GetFullPath(holder.FileInformation.FilePath));
-        Assert.Equal(FileSystem.Path.GetFullPath(param.FilePath), FileSystem.Path.GetFullPath(((IPetroglyphFileHolder)holder).FileInformation.FilePath));
+    }
 
-        Assert.Equal(FileSystem.Path.GetFullPath(DefaultFileName), holder.FilePath);
-        Assert.Equal(FileSystem.Path.GetDirectoryName(FileSystem.Path.GetFullPath(DefaultFileName)), holder.Directory);
-        Assert.Same(ServiceProvider, holder.Services);
-        Assert.NotNull(holder.Logger);
+    [PlatformSpecificTheory(TestPlatformIdentifier.Linux)]
+    [InlineData("FOO\\BAR.XML")]
+    [InlineData("DATA\\XML\\FOO.XML")]
+    public void Ctor_LocalFile_BackslashIsLiteralFilenameChar_Linux(string filePath)
+    {
+        var model = CreateModel();
+        FileSystem.Initialize().WithFile(filePath);
+        var holder = CreateFileHolder(model, CreateFileInfo(filePath));
+
+        Assert.Equal(filePath, holder.FileName);
+        Assert.Equal("/", holder.Directory);
+        Assert.Equal("/" + filePath, holder.FilePath);
     }
 
     [Theory]
-    [InlineData("test", true)]
-    [InlineData("path/test", true)]
-    [InlineData("test", false)]
-    [InlineData("path/test", false)]
-    public void Ctor_SetupProperties_MegSupport(string path, bool inMeg)
+    [InlineData("foo.xml")]
+    [InlineData("FOO.XML")]
+    [InlineData("DATA\\FOO.XML")]
+    [InlineData("data/foo.xml")]
+    [InlineData("DATA\\XML\\FOO.XML")]
+    [InlineData("DATA/SUB\\FOO.XML")]
+    [InlineData("DATA\\SUB/FOO.XML")]
+    [InlineData("./DATA\\SUB/FOO.XML")]
+    [InlineData(".\\DATA\\SUB/FOO.XML")]
+    public void Ctor_InMeg_SetupProperties(string filePath)
     {
-        if (!typeof(TFileInfo).IsAssignableFrom(typeof(PetroglyphMegPackableFileInformation)))
+        if (!typeof(PetroglyphMegPackableFileInformation).IsAssignableFrom(typeof(TFileInfo)))
             return;
 
         var model = CreateModel();
-
-        if (!inMeg)
-            FileSystem.Initialize().WithFile(path);
-
-        var param = CreateFileInfo(path, inMeg);
-        Assert.Equal(inMeg, (param as PetroglyphMegPackableFileInformation)!.IsInsideMeg);
+        var param = CreateFileInfo(filePath, inMeg: true);
 
         var holder = CreateFileHolder(model, param);
 
-        Assert.Same(model, holder.Content);
-        Assert.Same(model, ((IPetroglyphFileHolder)holder).Content);
-        Assert.NotSame(holder.FileInformation, param);
-        Assert.NotSame(((IPetroglyphFileHolder)holder).FileInformation, param);
-
-        if (inMeg)
-        {
-            Assert.Equal(param.FilePath, holder.FilePath);
-            Assert.Equal(FileSystem.Path.GetDirectoryName(path), holder.Directory);
-            Assert.NotNull(holder.Directory);
+        var expectedFilePath = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? filePath
+            : filePath.Replace('\\', '/');
 
-            Assert.Equal(holder.FileInformation, param);
-        }
-        else
-        {
-            Assert.Equal(FileSystem.Path.GetFullPath(path), holder.FilePath);
-            Assert.Equal(FileSystem.Path.GetDirectoryName(FileSystem.Path.GetFullPath(path)), holder.Directory);
-
-            Assert.NotEqual(holder.FileInformation, param);
-        }
+        Assert.Equal(FileSystem.Path.GetFileName(expectedFilePath), holder.FileName);
+        Assert.Equal(expectedFilePath, holder.FilePath);
+        Assert.Equal(FileSystem.Path.GetDirectoryName(expectedFilePath), holder.Directory);
 
-        Assert.Same(ServiceProvider, holder.Services);
+        Assert.Equal(filePath, holder.FileInformation.FilePath);
+        Assert.NotSame(param, holder.FileInformation);
+        Assert.Equal(param, holder.FileInformation);
     }
 
     [PlatformSpecificTheory(TestPlatformIdentifier.Linux)]
@@ -107,52 +117,6 @@ public void PassingFileNames_Whitespace_Linux(string filePath, string? expectedF
         }
     }
 
-    [PlatformSpecificTheory(TestPlatformIdentifier.Windows)]
-    [InlineData("test.txt", "test.txt", "C:\\", "C:\\test.txt")]
-    [InlineData("./test", "test", "C:\\", "C:\\test")]
-    [InlineData("a/../test", "test", "C:\\", "C:\\test")]
-    [InlineData("üöä", "üöä", "C:\\", "C:\\üöä")]
-    [InlineData("a/b", "b", "C:\\a", "C:\\a\\b")]
-#if NET
-    [InlineData("test/\u00A0", "\u00A0", "C:\\test", "C:\\test\\\u00A0")]
-#endif
-    //[InlineData("\u00A0", "\u00A0", "C:\\\u00A0", "C:\\u00A0")] // Currently not possible due to https://github.com/TestableIO/System.IO.Abstractions/issues/1070
-    public void PassingFileNames_Windows(string filePath, string? expectedFileName, string expectedDirectory, string expectedFilePath)
-    {
-        var model = CreateModel();
-        FileSystem.Initialize().WithFile(filePath);
-        var holder = CreateFileHolder(model, CreateFileInfo(filePath));
-
-        if (expectedFileName is not null)
-        {
-            Assert.Equal(expectedFileName, holder.FileName);
-            Assert.Equal(expectedDirectory, holder.Directory);
-            Assert.Equal(expectedFilePath, holder.FilePath);
-        }
-    }
-
-    [PlatformSpecificTheory(TestPlatformIdentifier.Linux)]
-    [InlineData("test.txt", "test.txt", "/", "/test.txt")]
-    [InlineData("./test", "test", "/", "/test")]
-    [InlineData("a/../test", "test", "/", "/test")]
-    [InlineData("üöä", "üöä", "/", "/üöä")]
-    [InlineData("a/b", "b", "/a", "/a/b")]
-    [InlineData("test/\u00A0", "\u00A0", "/test", "/test/\u00A0")]
-    // [InlineData("\u00A0", "\u00A0", "/\u00A0", "/\u00A0")] // Currently not possible due to https://github.com/TestableIO/System.IO.Abstractions/issues/1070
-    public void PassingFileNames_Linux(string filePath, string? expectedFileName, string expectedDirectory, string expectedFilePath)
-    {
-        var model = CreateModel();
-        FileSystem.Initialize().WithFile(filePath);
-        var holder = CreateFileHolder(model, CreateFileInfo(filePath));
-
-        if (expectedFileName is not null)
-        {
-            Assert.Equal(expectedFileName, holder.FileName);
-            Assert.Equal(expectedDirectory, holder.Directory);
-            Assert.Equal(expectedFilePath, holder.FilePath);
-        }
-    }
-
     [PlatformSpecificTheory(TestPlatformIdentifier.Windows)]
     [InlineData("   ", typeof(ArgumentException))]
     public void Ctor_InvalidPath_Whitespace_Windows_Throws(string path, Type type)
@@ -180,7 +144,7 @@ public void Ctor_FileNotFound_Throws()
 
         Assert.Throws<FileNotFoundException>(() => CreateFileHolder(model, CreateFileInfo("notFound")));
 
-        if (!typeof(TFileInfo).IsAssignableFrom(typeof(PetroglyphMegPackableFileInformation)))
+        if (!typeof(PetroglyphMegPackableFileInformation).IsAssignableFrom(typeof(TFileInfo)))
             return;
 
         Assert.DoesNotThrow(() => CreateFileHolder(model, CreateFileInfo("notFound", true)));
@@ -208,11 +172,11 @@ public void FileInformation_ReturnsCopy()
         FileSystem.Initialize().WithFile(DefaultFileName);
         var disposableParam = CreateFileInfo(DefaultFileName);
         var holder = CreateFileHolder(model, disposableParam);
-        
+
         var a = holder.FileInformation;
         var b = holder.FileInformation;
         Assert.NotSame(a, b);
         Assert.Equal(a, b);
     }
 
-}
+}

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/PetroglyphFileInformationTest.cs

@@ -10,16 +10,39 @@ public class PetroglyphFileInformationTest
     [InlineData("")]
     public void EmptyPath_Throws(string? path)
     {
-        Assert.ThrowsAny<ArgumentException>(() => _ = new MegTestParam
+        Assert.ThrowsAny<ArgumentException>(() => _ = new TestMegFileInfo
         {
             FilePath = path!
         });
     }
 
+    [Theory]
+    [InlineData("file.txt")]
+    [InlineData("FILE.TXT")]
+    [InlineData("path/file.txt")]
+    [InlineData("PATH\\FILE.TXT")]
+    public void FilePath_ContainsRawData(string path)
+    {
+        Assert.Equal(path, new TestFileInfo
+        {
+            FilePath = path,
+        }.FilePath);
+        Assert.Equal(path, new TestMegFileInfo
+        {
+            FilePath = path,
+            IsInsideMeg = true
+        }.FilePath);
+        Assert.Equal(path, new TestMegFileInfo
+        {
+            FilePath = path,
+            IsInsideMeg = false
+        }.FilePath);
+    }
+
     [Fact]
     public void Dispose()
     {
-        var info = new MegTestParam
+        var info = new TestMegFileInfo
         {
             FilePath = "somePath"
         };

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/TestFileInfo.cs

@@ -0,0 +1,3 @@
+namespace PG.StarWarsGame.Files.Test;
+
+public record TestFileInfo : PetroglyphFileInformation;

PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/MegTestParam.cs → PG.StarWarsGame.Files/PG.StarWarsGame.Files.Test/TestMegFileInfo.cs

@@ -1,6 +1,6 @@
 namespace PG.StarWarsGame.Files.Test;
 
-public record MegTestParam : PetroglyphMegPackableFileInformation
+public record TestMegFileInfo : PetroglyphMegPackableFileInformation
 {
     public bool IsDisposed { get; private set; }