ExFat tests

.devcontainer/devcontainer.json

@@ -0,0 +1,10 @@
+{
+  "name": "C# Dev Container",
+  "image": "mcr.microsoft.com/devcontainers/dotnet",
+  "features": {
+    "ghcr.io/devcontainers/features/dotnet:2.2.2": {
+      "version": "9.0"
+    }
+  },
+  "postCreateCommand": "apt-get update && apt-get install -y exfatprogs"
+}

README.md

@@ -46,3 +46,15 @@ Restrictions of Windows, Linux and OsX are alle combined to an replacement patte
 - Edge case Unicode sanitization: [.NET Framework](https://learn.microsoft.com/en-us/dotnet/framework/whats-new/#character-categories) uses Unicode 8.0, while .NET 8+ uses a newer version to detect unpaired surrogates and unassigned code points.
   - This is relevant when dealing with emoticons.
   - For example, ["💏🏻"](https://emojipedia.org/kiss-light-skin-tone) will be sanitized when running on .NET Framework 4.8, while it is supported as a valid filename on modern filesystems
+
+## Test setup
+
+The ExFat specific tests are skipped as long as no ExFat filesystem is available. Use this snippet to enable them:
+
+```powershell
+$vhdpath = 'C:\temp\ExFatTestContainer.vhd'
+$vhdsize = 100MB
+New-VHD -Path $vhdpath -Dynamic -SizeBytes $vhdsize | Mount-VHD -Passthru |Initialize-Disk -Passthru |New-Partition -AssignDriveLetter -UseMaximumSize |Format-Volume -FileSystem 'exFAT' -Confirm:$false  -NewFileSystemLabel '{exfatLabel}' -Force|Out-Null
+```
+
+Running as admin will automaticly create and mount a Exfat drive while tests are running.

SanitizeFilenameTests/ExFatTooling/AutoPlayDisabledScope.cs

@@ -0,0 +1,74 @@
+using Microsoft.Win32;
+using System.Runtime.InteropServices;
+
+public class AutoPlayDisabledScope : IDisposable
+{
+    private const string AutoPlayRegKey = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer";
+    private const string AutoPlayRegValue = "NoDriveTypeAutoRun";
+    private const int DisableAllAutoPlay = 0xFF;
+
+    private static int? _originalValue;
+    private bool disposedValue;
+
+    public bool AutoPlayerInitialState { get; }
+
+    /// <summary>
+    /// Temporarily disables AutoPlay if it is enabled. Returns true if it was changed.
+    /// </summary>
+    public AutoPlayDisabledScope()
+    {
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            AutoPlayerInitialState = false;
+            return;
+        }
+
+        object? current = Registry.GetValue(AutoPlayRegKey, AutoPlayRegValue, null);
+        if (current is int value && value == DisableAllAutoPlay)
+        {
+            // Already disabled
+            AutoPlayerInitialState = false;
+            return;
+        }
+
+        _originalValue = current as int?;
+        Registry.SetValue(AutoPlayRegKey, AutoPlayRegValue, DisableAllAutoPlay, RegistryValueKind.DWord);
+        AutoPlayerInitialState = true;
+    }
+
+    /// <summary>
+    /// Restores the original AutoPlay setting if it was changed.
+    /// </summary>
+    public static void RestoreAutoPlay()
+    {
+        if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            return;
+        }
+
+        if (_originalValue.HasValue)
+        {
+            Registry.SetValue(AutoPlayRegKey, AutoPlayRegValue, _originalValue.Value, RegistryValueKind.DWord);
+            _originalValue = null;
+        }
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!disposedValue)
+        {
+            if (disposing)
+            {
+                RestoreAutoPlay();
+            }
+
+            disposedValue = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+}

SanitizeFilenameTests/ExFatTooling/ExFatFileWriteAsserterFactory.cs

@@ -0,0 +1,166 @@
+using System.Runtime.InteropServices;
+
+namespace SanitizeFilenameTests.ExFatTooling
+{
+    public class ExFatFileWriteAsserterFactory : FileWriteAsserter
+    {
+        public static FileWriteAsserter? TryGetOrCreateExFatPartition(out string reason)
+        {
+            reason = string.Empty;
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                if (TryGetExFatPartition(out string path))
+                    return new FileWriteAsserter(path);
+
+                reason = "ExFatFileWriteAsserterFactory is only applicable on Windows.";
+                return null;
+            }
+
+            if (RuntimeInformation.OSArchitecture == Architecture.Arm || RuntimeInformation.OSArchitecture == Architecture.Arm64)
+            {
+                if (TryGetExFatPartition(out string path))
+                    return new FileWriteAsserter(path);
+
+                reason = "Test is skipped on Windows ARM because VHD mounting is not supported.";
+                return null;
+            }
+
+            if (!IsRunningAsAdministrator())
+            {
+                if (TryGetExFatPartition(out string path))
+                    return new FileWriteAsserter(path);
+
+                reason = "Test requires administrator privileges to create and mount exFAT VHD or an mounted ExFat drive.";
+                return null;
+            }
+
+            var imageTempPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString("N"));
+            var exFatPartitionCreateInfo = CreateAndMountExFatPartition(imageTempPath);
+            FileWriteAsserter fileWriteAsserter = new(exFatPartitionCreateInfo.TempPathInExFatPartition, exFatPartitionCreateInfo.VhdxPath);
+
+            return fileWriteAsserter;
+        }
+
+        private static bool TryGetExFatPartition(out string path)
+        {
+            path = string.Empty;
+            try
+            {
+                foreach (var drive in DriveInfo.GetDrives())
+                {
+                    if (drive.IsReady && string.Equals(drive.DriveFormat, "exFAT", StringComparison.OrdinalIgnoreCase))
+                    {
+                        string testDir = Path.Combine(drive.RootDirectory.FullName, "test" + Guid.NewGuid().ToString("N"));
+                        Directory.CreateDirectory(testDir);
+                        path = testDir;
+                        return true;
+                    }
+                }
+            }
+            catch
+            {
+                // Ignore exceptions and return false
+            }
+            return false;
+        }
+
+        private static bool IsRunningAsAdministrator()
+        {
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                return false;
+            using var identity = System.Security.Principal.WindowsIdentity.GetCurrent();
+            var principal = new System.Security.Principal.WindowsPrincipal(identity);
+            return principal.IsInRole(System.Security.Principal.WindowsBuiltInRole.Administrator);
+        }
+
+        private static (string TempPathInExFatPartition, string VhdxPath) CreateAndMountExFatPartition(string ImageTempPath)
+        {
+            using AutoPlayDisabledScope autoPlayDisabledScope = new AutoPlayDisabledScope();
+
+            var vhdxPath = Path.Combine(ImageTempPath, $"exfat-test-{Guid.NewGuid():N}.vhdx");
+            string vhdxFileName = Path.GetFileName(vhdxPath);
+            // exFAT volume label max length is 11 characters
+            string exfatLabel = Guid.NewGuid().ToString("N").Substring(0, 11);
+
+            string psScript = $@"
+
+$vhdpath = '{vhdxPath}'
+$vhdsize = 100MB
+New-VHD -Path $vhdpath -Dynamic -SizeBytes $vhdsize | Mount-VHD -Passthru | Initialize-Disk -Passthru | Out-Null
+Start-Sleep -Seconds 2
+$disk = Get-Disk | Where-Object {{ $_.Location -like '*{vhdxFileName}*' }}
+$partition = New-Partition -DiskNumber $disk.Number -UseMaximumSize -AssignDriveLetter
+Format-Volume -Partition $partition -FileSystem 'exFAT' -Confirm:$false -NewFileSystemLabel '{exfatLabel}' -Force | Out-Null
+$partition.DriveLetter
+";
+            var process = new System.Diagnostics.Process
+            {
+                StartInfo = new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = "powershell",
+                    Arguments = $"-NoProfile -Command \"{psScript.Replace("\"", "`\"")}\"",
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    UseShellExecute = false,
+                    CreateNoWindow = true
+                }
+            };
+            process.Start();
+            string stdOut = process.StandardOutput.ReadToEnd().Trim();
+            string stdErr = process.StandardError.ReadToEnd();
+            process.WaitForExit();
+            if (process.ExitCode != 0 || !string.IsNullOrEmpty(stdErr))
+            {
+                throw new InvalidOperationException(
+                    $"Failed to create or mount exFAT VHDX for testing. Exit code: {process.ExitCode}. Output: {stdOut} Error: {stdErr}"
+                );
+            }
+
+            if (!string.IsNullOrEmpty(stdOut))
+            {
+                var TempPathOnExFat = stdOut + @":\test" + Guid.NewGuid();
+                if (!Directory.Exists(TempPathOnExFat))
+                    Directory.CreateDirectory(TempPathOnExFat);
+
+                return (TempPathOnExFat, vhdxPath);
+            }
+            else
+            {
+                throw new InvalidOperationException("Failed to create or mount exFAT VHDX for testing.");
+            }
+        }
+
+        public static void UnmountAndDeleteImage(string exfatVhdxPath)
+        {
+            if (!string.IsNullOrEmpty(exfatVhdxPath))
+            {
+                // Unmount the exFAT VHDX by its file path
+                var unmountProcess = new System.Diagnostics.Process
+                {
+                    StartInfo = new System.Diagnostics.ProcessStartInfo
+                    {
+                        FileName = "powershell",
+                        Arguments = $"-NoProfile -Command \"Dismount-VHD -Path '{exfatVhdxPath}'\"",
+                        RedirectStandardOutput = true,
+                        RedirectStandardError = true,
+                        UseShellExecute = false,
+                        CreateNoWindow = true
+                    }
+                };
+                unmountProcess.Start();
+                string stdOut = unmountProcess.StandardOutput.ReadToEnd();
+                string stdErr = unmountProcess.StandardError.ReadToEnd();
+                unmountProcess.WaitForExit();
+                if (unmountProcess.ExitCode != 0)
+                {
+                    throw new InvalidOperationException($"Failed to dismount exFAT VHD. Exit code: {unmountProcess.ExitCode}. Output: {stdOut} Error: {stdErr}");
+                }
+
+                if (File.Exists(exfatVhdxPath))
+                {
+                    File.Delete(exfatVhdxPath);
+                }
+            }
+        }
+    }
+}

SanitizeFilenameTests/FilenameTests/FileWriteAsserter.cs

@@ -1,15 +1,22 @@
-namespace SanitizeFilenameTests
+using SanitizeFilenameTests.ExFatTooling;
+
+namespace SanitizeFilenameTests
 {
-    public class FileWriteAsserter
+    public class FileWriteAsserter : IDisposable
     {
-        public FileWriteAsserter()
+        private bool disposedValue;
+
+        public FileWriteAsserter(string? tempPath = null, string? disposableVhdxPath = null)
         {
-            TempPath = Path.Combine(Path.GetTempPath(), "test" + Guid.NewGuid());
+            DisposableVhdxPath = disposableVhdxPath;
+            TempPath = tempPath ?? Path.Combine(Path.GetTempPath(), "test" + Guid.NewGuid());
+
             if (!Directory.Exists(TempPath))
                 Directory.CreateDirectory(TempPath);
         }
 
-        public string TempPath { get; }
+        public string? DisposableVhdxPath { get; }
+        public string TempPath { get; set; }
 
         internal void AssertCollection(List<(string, int)> validFilenames)
         {
@@ -26,9 +33,6 @@ internal void AssertCollection(List<(string, int)> validFilenames)
                 }
             });
 
-            //invalidFilenames.Add(("test", 1));
-            //invalidFilenames.Add(("test", 2));
-
             Assert.That(invalidFilenames.OrderBy(x => x.Item2), Is.Empty, GenerateAssertionMessage(invalidFilenames));
         }
 
@@ -62,5 +66,27 @@ private static string GenerateAssertionMessage(List<(string, int)> invalidFilena
         {
             return "Invalid chars: " + string.Join(", ", invalidFilenames.Select(x => $"{x.Item2}"));
         }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (disposing)
+                {
+                    if (DisposableVhdxPath != null)
+                        ExFatFileWriteAsserterFactory.UnmountAndDeleteImage(DisposableVhdxPath);
+                    else
+                        Directory.Delete(TempPath, true);
+                }
+
+                disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
     }
-}
+}

SanitizeFilenameTests/FilenameTests/LinuxSpecificTests.cs

@@ -12,8 +12,7 @@ public LinuxSpecificTests()
         [OneTimeTearDown]
         public void TearDown()
         {
-            if (Directory.Exists(FileWriteAsserter.TempPath))
-                Directory.Delete(FileWriteAsserter.TempPath, true);
+            FileWriteAsserter.Dispose();
         }
 
         [Test]

SanitizeFilenameTests/FilenameTests/OsXSpecificTests.cs

@@ -13,8 +13,7 @@ public OsXSpecificTests()
         [OneTimeTearDown]
         public void TearDown()
         {
-            if (Directory.Exists(FileWriteAsserter.TempPath))
-                Directory.Delete(FileWriteAsserter.TempPath, true);
+            FileWriteAsserter.Dispose();
         }
 
         public FileWriteAsserter FileWriteAsserter { get; }
@@ -47,7 +46,7 @@ public void MacOsDoesNotSupportToWriteNotAssignedCodepointsWithSurrogates()
         [Test]
         public void ShouldSanitizeValidSurrogatesWithoutFollowingCodepoint()
         {
-            // https://unicodelookup.com/#557056/1  
+            // https://unicodelookup.com/#557056/1
             var oneOfManyValuesFoundByRunningEveryPossibleUTF16ValueAgainstMacOs = 557056;
             var sanitizedFilenames = new List<(string, int)>();
             string unicodeString = char.ConvertFromUtf32(oneOfManyValuesFoundByRunningEveryPossibleUTF16ValueAgainstMacOs);
@@ -64,7 +63,6 @@ public void ShouldSanitizeValidSurrogatesWithoutFollowingCodepoint()
         [TestCase(3315)]
         // U+11F02 Kawi Sign Repha https://codepoints.net/U+11F02
         [TestCase(73474)]
-
         public void MacOsSupportToWriteCodePointsThatFailedOnOsXGibhutRunnersInBeginOf2024(int bogusOsXValue)
         {
             // https://unicodelookup.com/#423939/1