[Resizetizer] Prove the symlink fix across input, output and platform shapes

Extends the coverage added with the fix so the properties it relies on are
asserted rather than assumed.

Deletion behind links, from every direction:

* The project directory is reached through a link (already covered).
* Only the intermediate output directory is a link, which is what a
  redirected obj\ looks like.
* Only the source image directory is a link.

Ordinary cleanup is not weakened. Verified with two mutations of
DetectStaleOutputFilesTask: never reporting a file stale fails 10 tests
(8 unit, 2 end to end), so the cleanup path is genuinely guarded.

Deletes cannot escape the intermediate root. StaleFiles is returned from
the input Files verbatim, never as the canonical spelling, so <Delete>
only ever sees paths under the wildcard's root:

* StaleFilesAreReturnedVerbatimEvenWhenCanonicalizationChangesTheSpelling
* StaleFilesAreAlwaysASubsetOfTheInputFiles
* ALinkPointingOutsideTheDirectoryIsReportedByItsInsidePath, which covers
  a link inside the intermediate directory that points outside it. MSBuild
  deletes the link and never the file it points at.

Returning the canonical path instead fails 8 tests, so this is pinned too.

Unix and Windows semantics, each asserted where the code supports it:

* Case sensitivity follows the platform, and the comparer choice itself is
  asserted. On Linux two spellings that differ only by case stay distinct;
  elsewhere they are the same file, which can only ever keep a stale file
  rather than delete a live one.
* Windows keeps its drive root and accepts both separator characters.
* Windows junctions resolve like directory links. .NET cannot create one,
  so the reparse point is written through DeviceIoControl, and the test
  skips where junctions are unavailable.
* Backslashes stay ordinary characters in Unix paths inside the
  canonicalizer, while MSBuild normalizes separators before the task ever
  sees an item spec, which is now asserted rather than assumed.

Also covers chained links, idempotence and canonicalizing a bare root.

All 14 end-to-end scenarios fail against the previous targets and pass
with them. Note that the non-linked variants fail too: Path.GetTempPath
on macOS returns a path under /var, which is itself a link to /private/var,
so any build from a temp directory reproduced the bug.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: Redth

src/SingleProject/Resizetizer/test/UnitTests/DetectStaleOutputFilesTaskTests.cs

@@ -88,18 +88,6 @@ public void RedundantSegmentsDoNotMakeAFileStale()
 			Assert.Empty(task.StaleFiles);
 		}
 
-		[Fact]
-		public void AlternateDirectorySeparatorsDoNotMakeAFileStale()
-		{
-			var kept = Path.Combine(DestinationDirectory, "drawable", "camera.png");
-			var spelledDifferently = kept.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-
-			var task = GetNewTask(new[] { spelledDifferently }, new[] { kept });
-
-			Assert.True(task.Execute());
-			Assert.Empty(task.StaleFiles);
-		}
-
 		[Fact]
 		public void FilesReachedThroughALinkedDirectoryAreNotStale()
 		{
@@ -147,5 +135,146 @@ public void StaleFilesInALinkedDirectoryAreStillDetected()
 			Assert.True(task.Execute());
 			Assert.Equal(stale, Assert.Single(task.StaleFiles).ItemSpec);
 		}
+
+		/// <summary>
+		/// The item specs handed back are what <c>&lt;Delete&gt;</c> acts on, so they must be the exact
+		/// strings that came in. Returning the canonical spelling instead would let a delete reach
+		/// outside the intermediate directory the wildcard was rooted at.
+		/// </summary>
+		[Fact]
+		public void StaleFilesAreReturnedVerbatimEvenWhenCanonicalizationChangesTheSpelling()
+		{
+			var physical = Path.Combine(DestinationDirectory, "physical");
+			var link = Path.Combine(DestinationDirectory, "link");
+			Directory.CreateDirectory(Path.Combine(physical, "drawable"));
+
+			if (!SymbolicLink.TryCreateDirectoryLink(link, physical, out var error))
+			{
+				Output.WriteLine($"Skipping: symbolic links are not available on this machine: {error}");
+				return;
+			}
+
+			var stale = Path.Combine(link, "drawable", "orphan.png");
+			File.WriteAllText(stale, "image");
+
+			var canonicalizer = new PathCanonicalizer();
+			Assert.NotEqual(stale, canonicalizer.Canonicalize(stale), PathCanonicalizer.Comparer);
+
+			var task = GetNewTask(new[] { stale }, System.Array.Empty<string>());
+
+			Assert.True(task.Execute());
+			Assert.Equal(stale, Assert.Single(task.StaleFiles).ItemSpec);
+		}
+
+		/// <summary>
+		/// A file inside the intermediate directory that is itself a link to somewhere else canonicalizes
+		/// to a path outside that directory, but it is still reported by its inside spelling, so
+		/// <c>&lt;Delete&gt;</c> removes the link and never the file it points at.
+		/// </summary>
+		[Fact]
+		public void ALinkPointingOutsideTheDirectoryIsReportedByItsInsidePath()
+		{
+			var outside = Path.Combine(DestinationDirectory, "outside");
+			var intermediate = Path.Combine(DestinationDirectory, "intermediate");
+			Directory.CreateDirectory(outside);
+			Directory.CreateDirectory(intermediate);
+
+			var target = Path.Combine(outside, "source.png");
+			File.WriteAllText(target, "not a build output");
+
+			var inside = Path.Combine(intermediate, "linked.png");
+			if (!SymbolicLink.TryCreateFileLink(inside, target, out var error))
+			{
+				Output.WriteLine($"Skipping: symbolic links are not available on this machine: {error}");
+				return;
+			}
+
+			var task = GetNewTask(new[] { inside }, System.Array.Empty<string>());
+
+			Assert.True(task.Execute());
+			Assert.Equal(inside, Assert.Single(task.StaleFiles).ItemSpec);
+		}
+
+		/// <summary>
+		/// Every returned item has to come from <see cref="DetectStaleOutputFilesTask.Files"/>. Nothing may
+		/// be invented, and nothing that was declared as an output may be returned.
+		/// </summary>
+		[Fact]
+		public void StaleFilesAreAlwaysASubsetOfTheInputFiles()
+		{
+			var files = new[]
+			{
+				Path.Combine(DestinationDirectory, "drawable", "camera.png"),
+				Path.Combine(DestinationDirectory, "drawable", "orphan.png"),
+				Path.Combine(DestinationDirectory, "drawable-xhdpi", "camera.png"),
+			};
+
+			var known = new[]
+			{
+				files[0],
+				// Declared as an output but not on disk, and a sibling that was never enumerated.
+				Path.Combine(DestinationDirectory, "drawable-hdpi", "camera.png"),
+			};
+
+			var task = GetNewTask(files, known);
+
+			Assert.True(task.Execute());
+
+			var stale = task.StaleFiles.Select(f => f.ItemSpec).ToArray();
+			Assert.All(stale, s => Assert.Contains(s, files));
+			Assert.Equal(new[] { files[1], files[2] }, stale);
+		}
+
+		[Fact]
+		public void EmptyAndWhitespaceItemSpecsAreIgnored()
+		{
+			var stale = Path.Combine(DestinationDirectory, "orphan.png");
+
+			var task = GetNewTask(new[] { "", "   ", stale }, new[] { "", "   " });
+
+			Assert.True(task.Execute());
+			Assert.Equal(stale, Assert.Single(task.StaleFiles).ItemSpec);
+		}
+
+		[Fact]
+		public void CaseOnlyDifferencesFollowThePlatformFileSystem()
+		{
+			var kept = Path.Combine(DestinationDirectory, "drawable", "camera.png");
+			var differentCase = Path.Combine(DestinationDirectory, "drawable", "CAMERA.png");
+
+			var task = GetNewTask(new[] { differentCase }, new[] { kept });
+
+			Assert.True(task.Execute());
+
+			if (OperatingSystem.IsLinux())
+			{
+				// Linux paths are case sensitive, so these really are two different files.
+				Assert.Equal(differentCase, Assert.Single(task.StaleFiles).ItemSpec);
+			}
+			else
+			{
+				// Windows and macOS are treated case insensitively. On a case sensitive macOS volume this
+				// can only ever keep a stale file, which is much safer than deleting a live one, and
+				// Resizetizer already rejects output names that differ only by case.
+				Assert.Empty(task.StaleFiles);
+			}
+		}
+
+		[Fact]
+		public void MSBuildNormalizesSeparatorsBeforeTheTaskSeesThem()
+		{
+			var kept = Path.Combine(DestinationDirectory, "drawable", "camera.png");
+
+			// MSBuild rewrites separators when it builds an item spec: on Unix a backslash becomes a
+			// forward slash, and on Windows both characters are separators anyway. Either way the task
+			// only ever receives paths that already use the platform separator, so canonicalization does
+			// not have to guess which character was meant.
+			var spelledWithBackslashes = kept.Replace(Path.DirectorySeparatorChar, '\\');
+
+			var task = GetNewTask(new[] { spelledWithBackslashes }, new[] { kept });
+
+			Assert.True(task.Execute());
+			Assert.Empty(task.StaleFiles);
+		}
 	}
 }

src/SingleProject/Resizetizer/test/UnitTests/Junction.cs

@@ -0,0 +1,104 @@
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+namespace Microsoft.Maui.Resizetizer.Tests
+{
+	/// <summary>
+	/// A junction is the other kind of Windows directory redirection a project can sit behind, and unlike
+	/// a symbolic link it does not need Developer Mode or elevation. .NET has no API to create one, so
+	/// the reparse point is written through the Win32 device control interface.
+	/// </summary>
+	[SupportedOSPlatform("windows")]
+	static class Junction
+	{
+		const uint FsctlSetReparsePoint = 0x000900A4;
+		const uint IoReparseTagMountPoint = 0xA0000003;
+		const uint GenericWrite = 0x40000000;
+		const uint FileShareAll = 0x00000001 | 0x00000002 | 0x00000004;
+		const uint OpenExisting = 3;
+		const uint FileFlagBackupSemantics = 0x02000000;
+		const uint FileFlagOpenReparsePoint = 0x00200000;
+
+		public static bool TryCreate(string junction, string target, out string error)
+		{
+			try
+			{
+				Create(junction, target);
+				error = null;
+				return true;
+			}
+			catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or Win32Exception or PlatformNotSupportedException)
+			{
+				error = ex.Message;
+				return false;
+			}
+		}
+
+		static void Create(string junction, string target)
+		{
+			Directory.CreateDirectory(junction);
+
+			// A mount point stores its target as an NT object path.
+			var printName = Path.GetFullPath(target);
+			var substituteName = @"\??\" + printName;
+
+			var substituteBytes = System.Text.Encoding.Unicode.GetBytes(substituteName);
+			var printBytes = System.Text.Encoding.Unicode.GetBytes(printName);
+
+			// REPARSE_DATA_BUFFER: 8 byte header, 8 bytes of mount point offsets/lengths, then the two
+			// null terminated names.
+			var pathBufferLength = substituteBytes.Length + 2 + printBytes.Length + 2;
+			var buffer = new byte[8 + 8 + pathBufferLength];
+
+			BitConverter.GetBytes(IoReparseTagMountPoint).CopyTo(buffer, 0);
+			BitConverter.GetBytes((ushort)(8 + pathBufferLength)).CopyTo(buffer, 4);
+			BitConverter.GetBytes((ushort)0).CopyTo(buffer, 6);
+			BitConverter.GetBytes((ushort)0).CopyTo(buffer, 8);
+			BitConverter.GetBytes((ushort)substituteBytes.Length).CopyTo(buffer, 10);
+			BitConverter.GetBytes((ushort)(substituteBytes.Length + 2)).CopyTo(buffer, 12);
+			BitConverter.GetBytes((ushort)printBytes.Length).CopyTo(buffer, 14);
+			substituteBytes.CopyTo(buffer, 16);
+			printBytes.CopyTo(buffer, 16 + substituteBytes.Length + 2);
+
+			using var handle = CreateFile(
+				junction,
+				GenericWrite,
+				FileShareAll,
+				IntPtr.Zero,
+				OpenExisting,
+				FileFlagBackupSemantics | FileFlagOpenReparsePoint,
+				IntPtr.Zero);
+
+			if (handle.IsInvalid)
+				throw new Win32Exception(Marshal.GetLastWin32Error());
+
+			if (!DeviceIoControl(handle, FsctlSetReparsePoint, buffer, buffer.Length, IntPtr.Zero, 0, out _, IntPtr.Zero))
+				throw new Win32Exception(Marshal.GetLastWin32Error());
+		}
+
+		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+		static extern Microsoft.Win32.SafeHandles.SafeFileHandle CreateFile(
+			string lpFileName,
+			uint dwDesiredAccess,
+			uint dwShareMode,
+			IntPtr lpSecurityAttributes,
+			uint dwCreationDisposition,
+			uint dwFlagsAndAttributes,
+			IntPtr hTemplateFile);
+
+		[DllImport("kernel32.dll", SetLastError = true)]
+		[return: MarshalAs(UnmanagedType.Bool)]
+		static extern bool DeviceIoControl(
+			Microsoft.Win32.SafeHandles.SafeFileHandle hDevice,
+			uint dwIoControlCode,
+			byte[] lpInBuffer,
+			int nInBufferSize,
+			IntPtr lpOutBuffer,
+			int nOutBufferSize,
+			out int lpBytesReturned,
+			IntPtr lpOverlapped);
+	}
+}

src/SingleProject/Resizetizer/test/UnitTests/PathCanonicalizerTests.cs

@@ -122,6 +122,118 @@ public void UnrelatedPathsStayDifferent()
 			Assert.NotEqual(one, two, PathCanonicalizer.Comparer);
 		}
 
+		[Fact]
+		public void CanonicalizingIsIdempotent()
+		{
+			var (physical, link) = CreateLinkedDirectory();
+			if (link is null)
+				return;
+
+			File.WriteAllText(Path.Combine(physical, "camera.png"), "image");
+
+			var canonicalizer = new PathCanonicalizer();
+			var once = canonicalizer.Canonicalize(Path.Combine(link, "camera.png"));
+
+			Assert.Equal(once, canonicalizer.Canonicalize(once), PathCanonicalizer.Comparer);
+		}
+
+		[Fact]
+		public void ChainedLinksResolveToTheFinalTarget()
+		{
+			var physical = Path.Combine(DestinationDirectory, "physical");
+			var first = Path.Combine(DestinationDirectory, "first");
+			var second = Path.Combine(DestinationDirectory, "second");
+			Directory.CreateDirectory(physical);
+
+			if (!SymbolicLink.TryCreateDirectoryLink(first, physical, out var error) ||
+				!SymbolicLink.TryCreateDirectoryLink(second, first, out error))
+			{
+				Output.WriteLine($"Skipping: symbolic links are not available on this machine: {error}");
+				return;
+			}
+
+			var canonicalizer = new PathCanonicalizer();
+
+			Assert.Equal(
+				canonicalizer.Canonicalize(Path.Combine(physical, "camera.png")),
+				canonicalizer.Canonicalize(Path.Combine(second, "camera.png")),
+				PathCanonicalizer.Comparer);
+		}
+
+		[Fact]
+		public void ComparerFollowsThePlatformFileSystem()
+		{
+			// Only Linux path comparison is case sensitive. Everywhere else two spellings that differ by
+			// case are treated as the same file, which can only ever keep a stale file rather than delete
+			// a live one.
+			Assert.Equal(OperatingSystem.IsLinux() ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase, PathCanonicalizer.Comparer);
+		}
+
+		[Fact]
+		public void RootsAreCanonicalizedWithoutRecursingForever()
+		{
+			var canonicalizer = new PathCanonicalizer();
+			var root = Path.GetPathRoot(Path.GetFullPath(DestinationDirectory));
+
+			Assert.False(string.IsNullOrEmpty(root));
+			Assert.Equal(root, canonicalizer.Canonicalize(root), PathCanonicalizer.Comparer);
+		}
+
+		[Fact]
+		public void WindowsPathsKeepTheirDriveAndAcceptBothSeparators()
+		{
+			if (!OperatingSystem.IsWindows())
+				return;
+
+			var canonicalizer = new PathCanonicalizer();
+			var path = Path.Combine(DestinationDirectory, "drawable", "camera.png");
+
+			Assert.Equal(
+				canonicalizer.Canonicalize(path),
+				canonicalizer.Canonicalize(path.Replace('\\', '/')),
+				PathCanonicalizer.Comparer);
+
+			Assert.Equal(Path.GetPathRoot(path), Path.GetPathRoot(canonicalizer.Canonicalize(path)), StringComparer.OrdinalIgnoreCase);
+		}
+
+		[Fact]
+		public void WindowsJunctionsResolveLikeDirectoryLinks()
+		{
+			if (!OperatingSystem.IsWindows())
+				return;
+
+			var physical = Path.Combine(DestinationDirectory, "physical");
+			var junction = Path.Combine(DestinationDirectory, "junction");
+			Directory.CreateDirectory(physical);
+
+			if (!Junction.TryCreate(junction, physical, out var error))
+			{
+				Output.WriteLine($"Skipping: junctions are not available on this machine: {error}");
+				return;
+			}
+
+			var canonicalizer = new PathCanonicalizer();
+
+			Assert.Equal(
+				canonicalizer.Canonicalize(Path.Combine(physical, "camera.png")),
+				canonicalizer.Canonicalize(Path.Combine(junction, "camera.png")),
+				PathCanonicalizer.Comparer);
+		}
+
+		[Fact]
+		public void BackslashesAreOrdinaryCharactersOnUnix()
+		{
+			if (OperatingSystem.IsWindows())
+				return;
+
+			var canonicalizer = new PathCanonicalizer();
+
+			var withBackslash = canonicalizer.Canonicalize(Path.Combine(DestinationDirectory, "drawable\\camera.png"));
+			var withSeparator = canonicalizer.Canonicalize(Path.Combine(DestinationDirectory, "drawable", "camera.png"));
+
+			Assert.NotEqual(withBackslash, withSeparator, PathCanonicalizer.Comparer);
+		}
+
 		(string Physical, string Link) CreateLinkedDirectory()
 		{
 			var physical = Path.Combine(DestinationDirectory, "physical");