Make RuntimeHostInfoTests more robust (#81080)

jjonescz · web-flow · commit a065eaef112f · 2025-11-11T13:59:09.000Z
diff --git a/src/Compilers/Core/MSBuildTaskTests/RuntimeHostInfoTests.cs b/src/Compilers/Core/MSBuildTaskTests/RuntimeHostInfoTests.cs
@@ -2,9 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.IO;
 using System.Runtime.InteropServices;
+using Microsoft.CodeAnalysis.CommandLine;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
@@ -13,75 +13,91 @@
 
 namespace Microsoft.CodeAnalysis.BuildTasks.UnitTests;
 
-public sealed class RuntimeHostInfoTests(ITestOutputHelper output)
+public sealed class RuntimeHostInfoTests(ITestOutputHelper output) : TestBase
 {
     private readonly ITestOutputHelper _output = output;
 
+    /// <summary>
+    /// Normalizes a path by resolving any symbolic links or subst drives (on Windows).
+    /// This ensures paths can be compared even when one is a subst drive (e.g., T:\ -> D:\a\_work\1\s\artifacts\tmp\Debug).
+    /// </summary>
+    private static string NormalizePath(string path)
+    {
+        // Our test infra uses `subst` which the .NET Core's implementation of `ResolveLinkTarget` wouldn't resolve,
+        // hence we always use our Win32 polyfill on Windows to ensure paths are fully normalized and can be compared in tests.
+        var resolvedPath = PlatformInformation.IsWindows
+            ? NativeMethods.ResolveLinkTargetWin32(path, returnFinalTarget: true)
+            : File.ResolveLinkTarget(path, returnFinalTarget: true);
+        if (resolvedPath != null)
+        {
+            return resolvedPath.FullName;
+        }
+
+        return path;
+    }
+
     [Fact, WorkItem("https://github.com/dotnet/msbuild/issues/12669")]
     public void DotNetInPath()
     {
-        var previousPath = Environment.GetEnvironmentVariable("PATH");
-        try
-        {
-            using var tempRoot = new TempRoot();
-            var testDir = tempRoot.CreateDirectory();
-            var globalDotNetDir = testDir.CreateDirectory("global-dotnet");
-            var globalDotNetExe = globalDotNetDir.CreateFile($"dotnet{PlatformInformation.ExeExtension}");
-            Environment.SetEnvironmentVariable("PATH", globalDotNetDir.Path);
+        using var tempRoot = new TempRoot();
+        var testDir = tempRoot.CreateDirectory();
+        var globalDotNetDir = testDir.CreateDirectory("global-dotnet");
+        var globalDotNetExe = globalDotNetDir.CreateFile($"dotnet{PlatformInformation.ExeExtension}");
 
-            Assert.Equal(globalDotNetDir.Path, RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
-        }
-        finally
-        {
-            Environment.SetEnvironmentVariable("PATH", previousPath);
-        }
+        var result = ApplyEnvironmentVariables(
+        [
+            new("PATH", globalDotNetDir.Path),
+            new(RuntimeHostInfo.DotNetHostPathEnvironmentName, ""),
+            new(RuntimeHostInfo.DotNetExperimentalHostPathEnvironmentName, ""),
+        ],
+        () => RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
+
+        Assert.NotNull(result);
+        AssertEx.Equal(NormalizePath(globalDotNetDir.Path), NormalizePath(result));
     }
 
     [Fact, WorkItem("https://github.com/dotnet/msbuild/issues/12669")]
     public void DotNetInPath_None()
     {
-        var previousPath = Environment.GetEnvironmentVariable("PATH");
-        try
-        {
-            Environment.SetEnvironmentVariable("PATH", "");
+        var result = ApplyEnvironmentVariables(
+        [
+            new("PATH", ""),
+            new(RuntimeHostInfo.DotNetHostPathEnvironmentName, ""),
+            new(RuntimeHostInfo.DotNetExperimentalHostPathEnvironmentName, ""),
+        ],
+        () => RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
 
-            Assert.Null(RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
-        }
-        finally
-        {
-            Environment.SetEnvironmentVariable("PATH", previousPath);
-        }
+        Assert.Null(result);
     }
 
     [Fact, WorkItem("https://github.com/dotnet/msbuild/issues/12669")]
     public void DotNetInPath_Symlinked()
     {
-        var previousPath = Environment.GetEnvironmentVariable("PATH");
-        try
-        {
-            using var tempRoot = new TempRoot();
-            var testDir = tempRoot.CreateDirectory();
-            var globalDotNetDir = testDir.CreateDirectory("global-dotnet");
-            var globalDotNetExe = globalDotNetDir.CreateFile($"dotnet{PlatformInformation.ExeExtension}");
-            var binDir = testDir.CreateDirectory("bin");
-            var symlinkPath = Path.Combine(binDir.Path, $"dotnet{PlatformInformation.ExeExtension}");
+        using var tempRoot = new TempRoot();
+        var testDir = tempRoot.CreateDirectory();
+        var globalDotNetDir = testDir.CreateDirectory("global-dotnet");
+        var globalDotNetExe = globalDotNetDir.CreateFile($"dotnet{PlatformInformation.ExeExtension}");
+        var binDir = testDir.CreateDirectory("bin");
+        var symlinkPath = Path.Combine(binDir.Path, $"dotnet{PlatformInformation.ExeExtension}");
 
-            // Create symlink from binDir to the actual dotnet executable
-            File.CreateSymbolicLink(path: symlinkPath, pathToTarget: globalDotNetExe.Path);
+        // Create symlink from binDir to the actual dotnet executable
+        File.CreateSymbolicLink(path: symlinkPath, pathToTarget: globalDotNetExe.Path);
 
-            Environment.SetEnvironmentVariable("PATH", binDir.Path);
+        var result = ApplyEnvironmentVariables(
+        [
+            new("PATH", binDir.Path),
+            new(RuntimeHostInfo.DotNetHostPathEnvironmentName, ""),
+            new(RuntimeHostInfo.DotNetExperimentalHostPathEnvironmentName, ""),
+        ],
+        () => RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
 
-            Assert.Equal(globalDotNetDir.Path, RuntimeHostInfo.GetToolDotNetRoot(_output.WriteLine));
-        }
-        finally
-        {
-            Environment.SetEnvironmentVariable("PATH", previousPath);
-        }
+        Assert.NotNull(result);
+        AssertEx.Equal(NormalizePath(globalDotNetDir.Path), NormalizePath(result));
     }
 }
 
 #if !NET
-file static class NativeMethods
+file static class TestNativeMethods
 {
     extension(File)
     {
diff --git a/src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs b/src/Compilers/Server/VBCSCompilerTests/CompilerServerTests.cs
@@ -6,16 +6,12 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.InteropServices;
 using System.Text;
-using System.Threading;
 using System.Threading.Tasks;
 using Basic.Reference.Assemblies;
-using Castle.Core.Resource;
 using Microsoft.CodeAnalysis.CommandLine;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Roslyn.Test.Utilities;
@@ -117,35 +113,6 @@ private static void CreateFiles(TempDirectory currentDirectory, IEnumerable<KeyV
             }
         }
 
-        private static T ApplyEnvironmentVariables<T>(
-            IEnumerable<KeyValuePair<string, string>> environmentVariables,
-            Func<T> func)
-        {
-            if (environmentVariables == null)
-            {
-                return func();
-            }
-
-            var resetVariables = new Dictionary<string, string>();
-            try
-            {
-                foreach (var variable in environmentVariables)
-                {
-                    resetVariables.Add(variable.Key, Environment.GetEnvironmentVariable(variable.Key));
-                    Environment.SetEnvironmentVariable(variable.Key, variable.Value);
-                }
-
-                return func();
-            }
-            finally
-            {
-                foreach (var variable in resetVariables)
-                {
-                    Environment.SetEnvironmentVariable(variable.Key, variable.Value);
-                }
-            }
-        }
-
         private static (T Result, string Output) UseTextWriter<T>(Encoding encoding, Func<TextWriter, T> func)
         {
             MemoryStream memoryStream;
diff --git a/src/Compilers/Shared/NativeMethods.cs b/src/Compilers/Shared/NativeMethods.cs
@@ -104,33 +104,43 @@ out PROCESS_INFORMATION lpProcessInformation
         {
             public static FileSystemInfo? ResolveLinkTarget(string path, bool returnFinalTarget)
             {
-                if (!returnFinalTarget) throw new NotSupportedException();
-
-                using var handle = CreateFileW(
-                    lpFileName: path,
-                    dwDesiredAccess: FILE_READ_ATTRIBUTES,
-                    dwShareMode: FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                    lpSecurityAttributes: IntPtr.Zero,
-                    dwCreationDisposition: OPEN_EXISTING,
-                    dwFlagsAndAttributes: FILE_FLAG_BACKUP_SEMANTICS, // needed for directories
-                    hTemplateFile: IntPtr.Zero);
-
-                if (handle.IsInvalid)
-                {
-                    return null;
-                }
-
-                uint flags = FILE_NAME_NORMALIZED | VOLUME_NAME_DOS;
-                uint needed = GetFinalPathNameByHandleW(hFile: handle, lpszFilePath: null, cchFilePath: 0, dwFlags: flags);
-                if (needed == 0) return null;
-
-                var sb = new StringBuilder((int)needed + 1);
-                uint len = GetFinalPathNameByHandleW(hFile: handle, lpszFilePath: sb, cchFilePath: (uint)sb.Capacity, dwFlags: flags);
-                if (len == 0) return null;
-
-                return new FileInfo(TrimWin32ExtendedPrefix(sb.ToString()));
+                return ResolveLinkTargetWin32(path, returnFinalTarget);
             }
         }
+#endif
+
+        /// <remarks>
+        /// Unlike .NET Core's implementation of <c>File.ResolveLinkTarget</c>,
+        /// this resolves virtual disk mappings (created via <c>subst</c>).
+        /// </remarks>
+        public static FileSystemInfo? ResolveLinkTargetWin32(string path, bool returnFinalTarget)
+        {
+            if (!returnFinalTarget) throw new NotSupportedException();
+
+            using var handle = CreateFileW(
+                lpFileName: path,
+                dwDesiredAccess: FILE_READ_ATTRIBUTES,
+                dwShareMode: FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                lpSecurityAttributes: IntPtr.Zero,
+                dwCreationDisposition: OPEN_EXISTING,
+                dwFlagsAndAttributes: FILE_FLAG_BACKUP_SEMANTICS, // needed for directories
+                hTemplateFile: IntPtr.Zero);
+
+            if (handle.IsInvalid)
+            {
+                return null;
+            }
+
+            uint flags = FILE_NAME_NORMALIZED | VOLUME_NAME_DOS;
+            uint needed = GetFinalPathNameByHandleW(hFile: handle, lpszFilePath: null, cchFilePath: 0, dwFlags: flags);
+            if (needed == 0) return null;
+
+            var sb = new StringBuilder((int)needed + 1);
+            uint len = GetFinalPathNameByHandleW(hFile: handle, lpszFilePath: sb, cchFilePath: (uint)sb.Capacity, dwFlags: flags);
+            if (len == 0) return null;
+
+            return new FileInfo(TrimWin32ExtendedPrefix(sb.ToString()));
+        }
 
         private static string TrimWin32ExtendedPrefix(string s)
         {
@@ -173,7 +183,6 @@ private static extern uint GetFinalPathNameByHandleW(
             StringBuilder? lpszFilePath,
             uint cchFilePath,
             uint dwFlags);
-#endif
 
     }
 }
diff --git a/src/Compilers/Shared/RuntimeHostInfo.cs b/src/Compilers/Shared/RuntimeHostInfo.cs
@@ -27,8 +27,8 @@ internal static class RuntimeHostInfo
 #endif
 
         internal const string DotNetRootEnvironmentName = "DOTNET_ROOT";
-        private const string DotNetHostPathEnvironmentName = "DOTNET_HOST_PATH";
-        private const string DotNetExperimentalHostPathEnvironmentName = "DOTNET_EXPERIMENTAL_HOST_PATH";
+        internal const string DotNetHostPathEnvironmentName = "DOTNET_HOST_PATH";
+        internal const string DotNetExperimentalHostPathEnvironmentName = "DOTNET_EXPERIMENTAL_HOST_PATH";
 
         /// <summary>
         /// The <c>DOTNET_ROOT</c> that should be used when launching executable tools.
@@ -48,7 +48,7 @@ internal static class RuntimeHostInfo
             }
             catch (Exception ex)
             {
-                logger?.Invoke("Failed to resolve symbolic link for dotnet path '{0}': {1}", [dotNetPath, ex.Message]);
+                logger?.Invoke("Failed to resolve symbolic link for dotnet path '{0}': {1}", [dotNetPath, ex]);
                 return null;
             }
 
diff --git a/src/Compilers/Test/Core/TestBase.cs b/src/Compilers/Test/Core/TestBase.cs
@@ -3,20 +3,17 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Diagnostics;
+using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Reflection;
 using System.Threading;
 using System.Xml.Linq;
+using Basic.Reference.Assemblies;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
-using Microsoft.CodeAnalysis.VisualBasic;
-using static TestReferences.NetFx;
-using Basic.Reference.Assemblies;
-using Roslyn.Utilities;
-using System.Globalization;
 
 namespace Roslyn.Test.Utilities
 {
@@ -363,5 +360,34 @@ internal static DiagnosticDescription Diagnostic(
         }
 
         #endregion
+
+        public static T ApplyEnvironmentVariables<T>(
+            IEnumerable<KeyValuePair<string, string?>> environmentVariables,
+            Func<T> func)
+        {
+            if (environmentVariables == null)
+            {
+                return func();
+            }
+
+            var resetVariables = new Dictionary<string, string?>();
+            try
+            {
+                foreach (var variable in environmentVariables)
+                {
+                    resetVariables.Add(variable.Key, Environment.GetEnvironmentVariable(variable.Key));
+                    Environment.SetEnvironmentVariable(variable.Key, variable.Value);
+                }
+
+                return func();
+            }
+            finally
+            {
+                foreach (var variable in resetVariables)
+                {
+                    Environment.SetEnvironmentVariable(variable.Key, variable.Value);
+                }
+            }
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ internal static class RuntimeHostInfo`
`27`	`27`	`#endif`
`28`	`28`
`29`	`29`	`internal const string DotNetRootEnvironmentName = "DOTNET_ROOT";`
`30`		`- private const string DotNetHostPathEnvironmentName = "DOTNET_HOST_PATH";`
`31`		`- private const string DotNetExperimentalHostPathEnvironmentName = "DOTNET_EXPERIMENTAL_HOST_PATH";`
	`30`	`+ internal const string DotNetHostPathEnvironmentName = "DOTNET_HOST_PATH";`
	`31`	`+ internal const string DotNetExperimentalHostPathEnvironmentName = "DOTNET_EXPERIMENTAL_HOST_PATH";`
`32`	`32`
`33`	`33`	`/// <summary>`
`34`	`34`	`/// The <c>DOTNET_ROOT</c> that should be used when launching executable tools.`
`@@ -48,7 +48,7 @@ internal static class RuntimeHostInfo`
`48`	`48`	`}`
`49`	`49`	`catch (Exception ex)`
`50`	`50`	`{`
`51`		`- logger?.Invoke("Failed to resolve symbolic link for dotnet path '{0}': {1}", [dotNetPath, ex.Message]);`
	`51`	`+ logger?.Invoke("Failed to resolve symbolic link for dotnet path '{0}': {1}", [dotNetPath, ex]);`
`52`	`52`	`return null;`
`53`	`53`	`}`
`54`	`54`