Merge main and fix code review issues in artifact naming service

- Remove <root> placeholder (fragile directory traversal)
- Fix OperatingSystem.IsWindows/IsLinux/IsMacOS for netstandard2.0 compat (use RuntimeInformation)
- Fix KeyValuePair deconstruction for netstandard2.0 compat
- Fix Guard.NotNullOrEmpty (non-existent API)
- Fix legacy %p pattern handling (move to HangDump caller, not the service)
- Fix time format to use hyphens instead of colons (filesystem safe)
- Remove unnecessary using directives
- Simplify GetOperatingSystemName with ternary expression
- Simplify TFM detection (remove hard-coded version map)
- Fix tests: use Assert.ThrowsExactly, match constructor signature, update assertions

Author: Evangelink

docs/ArtifactNamingService.md

@@ -2,9 +2,7 @@
 
 The artifact naming service provides a standardized way to generate consistent names and paths for test artifacts across all extensions.
 
-## Features
-
-### Template-Based Naming
+## Template-Based Naming
 
 Use placeholders in angle brackets to create dynamic file names:
 
@@ -14,17 +12,7 @@ Use placeholders in angle brackets to create dynamic file names:
 
 Resolves to: `MyTests_12345_a1b2c3d4_hang.dmp`
 
-### Complex Path Templates
-
-Create structured directory layouts:
-
-```text
-<root>/artifacts/<os>/<asm>/dumps/<pname>_<pid>_<tfm>_<time>.dmp
-```
-
-Resolves to: `c:/myproject/artifacts/linux/MyTests/dumps/my-child-process_10001_net9.0_2025-09-22T13:49:34.dmp`
-
-### Available Placeholders
+## Available Placeholders
 
 | Placeholder | Description | Example |
 |-------------|-------------|---------|
@@ -34,28 +22,17 @@ Resolves to: `c:/myproject/artifacts/linux/MyTests/dumps/my-child-process_10001_
 | `<os>` | Operating system | `windows`, `linux`, `macos` |
 | `<asm>` | Assembly name | `MyTests` |
 | `<tfm>` | Target framework moniker | `net9.0`, `net8.0` |
-| `<time>` | Timestamp (1-second precision) | `2025-09-22T13:49:34` |
-| `<root>` | Project root directory | Found via solution/git/working dir |
+| `<time>` | Timestamp (1-second precision) | `2025-09-22T13-49-34` |
 
-### Backward Compatibility
+## Backward Compatibility
 
-Legacy patterns are still supported:
+Legacy patterns like `%p` continue to work in the hang dump extension.
 
-```csharp
-// Old pattern
-"myfile_%p.dmp"
-
-// Works with legacy support
-service.ResolveTemplateWithLegacySupport("myfile_%p.dmp",
-    legacyReplacements: new Dictionary<string, string> { ["%p"] = "12345" });
-```
-
-### Custom Replacements
+## Custom Replacements
 
 Override default values for specific scenarios:
 
 ```csharp
-// When dumping a different process than the test host
 var customReplacements = new Dictionary<string, string>
 {
     ["pname"] = "Notepad",
@@ -66,41 +43,14 @@ string result = service.ResolveTemplate("<pname>_<pid>.dmp", customReplacements)
 // Result: "Notepad_1111.dmp"
 ```
 
-## Usage in Extensions
-
-Extensions can use the service through dependency injection:
-
-```csharp
-public class MyExtension
-{
-    private readonly IArtifactNamingService _artifactNamingService;
-
-    public MyExtension(IServiceProvider serviceProvider)
-    {
-        _artifactNamingService = serviceProvider.GetArtifactNamingService();
-    }
-
-    public void CreateArtifact(string template)
-    {
-        string fileName = _artifactNamingService.ResolveTemplate(template);
-        // Use fileName for artifact creation
-    }
-}
-```
-
 ## Hang Dump Integration
 
-The hang dump extension now uses the artifact naming service and supports both legacy and modern patterns:
+The hang dump extension uses the artifact naming service and supports both legacy and modern patterns:
 
 ```text
 # Legacy pattern (still works)
 --hangdump-filename "mydump_%p.dmp"
 
 # New template pattern
 --hangdump-filename "<pname>_<pid>_<id>_hang.dmp"
-
-# Complex path template
---hangdump-filename "<root>/dumps/<os>/<pname>_<pid>_<time>.dmp"
 ```
-
-This provides consistent artifact naming across all extensions while maintaining backward compatibility.

src/Platform/Microsoft.Testing.Extensions.HangDump/HangDumpProcessLifetimeHandler.cs

@@ -311,14 +311,18 @@ private async Task TakeDumpAsync(IProcess process, CancellationToken cancellatio
         ApplicationStateGuard.Ensure(_testHostProcessInformation is not null);
         ApplicationStateGuard.Ensure(_dumpType is not null);
 
+        string processId = process.Id.ToString(CultureInfo.InvariantCulture);
         var customReplacements = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
         {
             ["pname"] = process.Name,
-            ["pid"] = process.Id.ToString(CultureInfo.InvariantCulture),
-            ["%p"] = process.Id.ToString(CultureInfo.InvariantCulture),
+            ["pid"] = processId,
         };
 
-        string finalDumpFileName = _artifactNamingService.ResolveTemplate(_dumpFileNamePattern ?? $"{process.Name}_%p_hang.dmp", customReplacements);
+        string pattern = _dumpFileNamePattern ?? $"{process.Name}_%p_hang.dmp";
+
+        // First resolve <placeholder> templates, then handle legacy %p pattern for backward compatibility.
+        string finalDumpFileName = _artifactNamingService.ResolveTemplate(pattern, customReplacements)
+            .Replace("%p", processId);
         finalDumpFileName = Path.Combine(_configuration.GetTestResultDirectory(), finalDumpFileName);
 
         ApplicationStateGuard.Ensure(_namedPipeClient is not null);

src/Platform/Microsoft.Testing.Platform/Services/ArtifactNamingService.cs

@@ -28,7 +28,10 @@ public ArtifactNamingService(
 
     public string ResolveTemplate(string template, IDictionary<string, string>? customReplacements = null)
     {
-        Guard.NotNullOrEmpty(template);
+        if (RoslynString.IsNullOrEmpty(template))
+        {
+            throw new ArgumentException("Template cannot be null or empty.", nameof(template));
+        }
 
         Dictionary<string, string> defaultReplacements = GetDefaultReplacements();
         Dictionary<string, string> allReplacements = MergeReplacements(defaultReplacements, customReplacements);
@@ -67,14 +70,11 @@ private Dictionary<string, string> GetDefaultReplacements()
         }
 
         // Time info (precision to 1 second)
-        replacements["time"] = _clock.UtcNow.ToString("yyyy-MM-ddTHH:mm:ss", CultureInfo.InvariantCulture);
+        replacements["time"] = _clock.UtcNow.ToString("yyyy-MM-ddTHH-mm-ss", CultureInfo.InvariantCulture);
 
         // Random ID for uniqueness
         replacements["id"] = GenerateShortId();
 
-        // Root directory
-        replacements["root"] = GetRootDirectory();
-
         return replacements;
     }
 
@@ -86,125 +86,55 @@ private static Dictionary<string, string> MergeReplacements(Dictionary<string, s
         }
 
         var merged = new Dictionary<string, string>(defaultReplacements, StringComparer.OrdinalIgnoreCase);
-        foreach ((string? key, string? value) in customReplacements)
+        foreach (KeyValuePair<string, string> kvp in customReplacements)
         {
-            merged[key] = value;
+            merged[kvp.Key] = kvp.Value;
         }
 
         return merged;
     }
 
     private static string GetOperatingSystemName()
-    {
-        if (OperatingSystem.IsWindows())
-        {
-            return "windows";
-        }
-
-        if (OperatingSystem.IsLinux())
-        {
-            return "linux";
-        }
-
-        if (OperatingSystem.IsMacOS())
-        {
-            return "macos";
-        }
-
-        // Fallback for unknown OS
-        return "unknown";
-    }
+        => RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "windows"
+            : RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? "linux"
+            : RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "macos"
+            : "unknown";
 
     private string GetTargetFrameworkMoniker()
     {
-        // Extract TFM from current runtime
         string frameworkDescription = RuntimeInformation.FrameworkDescription;
 
-        if (frameworkDescription.Contains(".NET Core"))
+        // .NET 5+ reports as ".NET X.Y.Z"
+        if (frameworkDescription.StartsWith(".NET ", StringComparison.Ordinal) &&
+            !frameworkDescription.StartsWith(".NET Framework", StringComparison.Ordinal) &&
+            !frameworkDescription.StartsWith(".NET Core", StringComparison.Ordinal))
         {
-            // Try to extract version from .NET Core description
-            Match match = Regex.Match(frameworkDescription, @"\.NET Core (\d+\.\d+)");
+            Match match = Regex.Match(frameworkDescription, @"\.NET (\d+)\.\d+");
             if (match.Success)
             {
-                return $"netcoreapp{match.Groups[1].Value}";
+                return $"net{match.Groups[1].Value}.0";
             }
         }
-        else if (frameworkDescription.Contains(".NET "))
+        else if (frameworkDescription.StartsWith(".NET Core", StringComparison.Ordinal))
         {
-            // Try to extract version from .NET 5+ description
-            Match match = Regex.Match(frameworkDescription, @"\.NET (\d+\.\d+)");
+            Match match = Regex.Match(frameworkDescription, @"\.NET Core (\d+\.\d+)");
             if (match.Success)
             {
-                string version = match.Groups[1].Value;
-                return version switch
-                {
-                    "5.0" => "net5.0",
-                    "6.0" => "net6.0",
-                    "7.0" => "net7.0",
-                    "8.0" => "net8.0",
-                    "9.0" => "net9.0",
-                    "10.0" => "net10.0",
-                    _ => $"net{version}",
-                };
+                return $"netcoreapp{match.Groups[1].Value}";
             }
         }
-        else if (frameworkDescription.Contains(".NET Framework"))
+        else if (frameworkDescription.StartsWith(".NET Framework", StringComparison.Ordinal))
         {
-            // Try to extract version from .NET Framework description
-            Match match = Regex.Match(frameworkDescription, @"\.NET Framework (\d+\.\d+)");
+            Match match = Regex.Match(frameworkDescription, @"\.NET Framework (\d+)\.(\d+)");
             if (match.Success)
             {
-                return $"net{match.Groups[1].Value.Replace(".", string.Empty)}";
+                return $"net{match.Groups[1].Value}{match.Groups[2].Value}";
             }
         }
 
         return _environment.Version.ToString();
     }
 
     private static string GenerateShortId()
-        => Guid.NewGuid().ToString("N")[..8];
-
-    private string GetRootDirectory()
-    {
-        string currentDirectory = _testApplicationModuleInfo.GetCurrentTestApplicationDirectory();
-
-        // Try to find solution root, git root, or working directory
-        string? rootDirectory = FindSolutionRoot(currentDirectory)
-            ?? FindGitRoot(currentDirectory)
-            ?? currentDirectory;
-
-        return rootDirectory;
-    }
-
-    private static string? FindSolutionRoot(string startDirectory)
-    {
-        string? directory = startDirectory;
-        while (directory is not null)
-        {
-            if (Directory.GetFiles(directory, "*.sln").Length > 0)
-            {
-                return directory;
-            }
-
-            directory = Directory.GetParent(directory)?.FullName;
-        }
-
-        return null;
-    }
-
-    private static string? FindGitRoot(string startDirectory)
-    {
-        string? directory = startDirectory;
-        while (directory is not null)
-        {
-            if (Directory.Exists(Path.Combine(directory, ".git")))
-            {
-                return directory;
-            }
-
-            directory = Directory.GetParent(directory)?.FullName;
-        }
-
-        return null;
-    }
+        => Guid.NewGuid().ToString("N").Substring(0, 8);
 }

src/Platform/Microsoft.Testing.Platform/Services/IArtifactNamingService.cs

@@ -5,7 +5,7 @@ namespace Microsoft.Testing.Platform.Services;
 
 /// <summary>
 /// Service for generating consistent artifact names and paths using template patterns.
-/// Supports placeholders like &lt;pname&gt;, &lt;pid&gt;, &lt;id&gt;, &lt;os&gt;, &lt;asm&gt;, &lt;tfm&gt;, &lt;time&gt;, &lt;root&gt;.
+/// Supports placeholders like &lt;pname&gt;, &lt;pid&gt;, &lt;id&gt;, &lt;os&gt;, &lt;asm&gt;, &lt;tfm&gt;, &lt;time&gt;.
 /// </summary>
 internal interface IArtifactNamingService
 {