Use file-scoped namespaces in RunTests source

eng/helix/content/RunTests/ProcessResult.cs

@@ -1,19 +1,18 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-namespace RunTests
+namespace RunTests;
+
+public class ProcessResult
 {
-    public class ProcessResult
+    public ProcessResult(string standardOutput, string standardError, int exitCode)
     {
-        public ProcessResult(string standardOutput, string standardError, int exitCode)
-        {
-            StandardOutput = standardOutput;
-            StandardError = standardError;
-            ExitCode = exitCode;
-        }
-
-        public string StandardOutput { get; }
-        public string StandardError { get; }
-        public int ExitCode { get; }
+        StandardOutput = standardOutput;
+        StandardError = standardError;
+        ExitCode = exitCode;
     }
+
+    public string StandardOutput { get; }
+    public string StandardError { get; }
+    public int ExitCode { get; }
 }

eng/helix/content/RunTests/ProcessUtil.cs

@@ -12,199 +12,198 @@
 
 #nullable enable
 
-namespace RunTests
+namespace RunTests;
+
+public static class ProcessUtil
 {
-    public static class ProcessUtil
+    [DllImport("libc", SetLastError = true, EntryPoint = "kill")]
+    private static extern int sys_kill(int pid, int sig);
+
+    public static Task CaptureDumpAsync()
     {
-        [DllImport("libc", SetLastError = true, EntryPoint = "kill")]
-        private static extern int sys_kill(int pid, int sig);
+        var dumpDirectoryPath = Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
 
-        public static Task CaptureDumpAsync()
+        if (dumpDirectoryPath == null)
         {
-            var dumpDirectoryPath = Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
+            return Task.CompletedTask;
+        }
 
-            if (dumpDirectoryPath == null)
-            {
-                return Task.CompletedTask;
-            }
+        var process = Process.GetCurrentProcess();
+        var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{process.ProcessName}-{process.Id}.dmp");
 
-            var process = Process.GetCurrentProcess();
-            var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{process.ProcessName}-{process.Id}.dmp");
+        return CaptureDumpAsync(process.Id, dumpFilePath);
+    }
 
-            return CaptureDumpAsync(process.Id, dumpFilePath);
-        }
+    public static Task CaptureDumpAsync(int pid)
+    {
+        var dumpDirectoryPath = Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
 
-        public static Task CaptureDumpAsync(int pid)
+        if (dumpDirectoryPath == null)
         {
-            var dumpDirectoryPath = Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
+            return Task.CompletedTask;
+        }
 
-            if (dumpDirectoryPath == null)
-            {
-                return Task.CompletedTask;
-            }
+        var process = Process.GetProcessById(pid);
+        var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{process.ProcessName}.{process.Id}.dmp");
 
-            var process = Process.GetProcessById(pid);
-            var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{process.ProcessName}.{process.Id}.dmp");
+        return CaptureDumpAsync(process.Id, dumpFilePath);
+    }
 
-            return CaptureDumpAsync(process.Id, dumpFilePath);
+    public static Task CaptureDumpAsync(int pid, string dumpFilePath)
+    {
+        // Skip this on OSX, we know it's unsupported right now
+        if (OperatingSystem.IsMacOS())
+        {
+            // Can we capture stacks or do a gcdump instead?
+            return Task.CompletedTask;
         }
 
-        public static Task CaptureDumpAsync(int pid, string dumpFilePath)
+        if (!File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump") &&
+            !File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump.exe"))
         {
-            // Skip this on OSX, we know it's unsupported right now
-            if (OperatingSystem.IsMacOS())
-            {
-                // Can we capture stacks or do a gcdump instead?
-                return Task.CompletedTask;
-            }
-
-            if (!File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump") &&
-                !File.Exists($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump.exe"))
-            {
-                return Task.CompletedTask;
-            }
-
-            return RunAsync($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump", $"collect -p {pid} -o \"{dumpFilePath}\"");
+            return Task.CompletedTask;
         }
 
-        public static async Task<ProcessResult> RunAsync(
-            string filename,
-            string arguments,
-            string? workingDirectory = null,
-            string? dumpDirectoryPath = null,
-            bool throwOnError = true,
-            IDictionary<string, string?>? environmentVariables = null,
-            Action<string>? outputDataReceived = null,
-            Action<string>? errorDataReceived = null,
-            Action<int>? onStart = null,
-            CancellationToken cancellationToken = default)
+        return RunAsync($"{Environment.GetEnvironmentVariable("HELIX_WORKITEM_ROOT")}/dotnet-dump", $"collect -p {pid} -o \"{dumpFilePath}\"");
+    }
+
+    public static async Task<ProcessResult> RunAsync(
+        string filename,
+        string arguments,
+        string? workingDirectory = null,
+        string? dumpDirectoryPath = null,
+        bool throwOnError = true,
+        IDictionary<string, string?>? environmentVariables = null,
+        Action<string>? outputDataReceived = null,
+        Action<string>? errorDataReceived = null,
+        Action<int>? onStart = null,
+        CancellationToken cancellationToken = default)
+    {
+        Console.WriteLine($"Running '{filename} {arguments}'");
+        using var process = new Process()
         {
-            Console.WriteLine($"Running '{filename} {arguments}'");
-            using var process = new Process()
-            {
-                StartInfo =
-                {
-                    FileName = filename,
-                    Arguments = arguments,
-                    RedirectStandardOutput = true,
-                    RedirectStandardError = true,
-                    UseShellExecute = false,
-                    CreateNoWindow = true,
-                },
-                EnableRaisingEvents = true
-            };
-
-            if (workingDirectory != null)
+            StartInfo =
             {
-                process.StartInfo.WorkingDirectory = workingDirectory;
-            }
+                FileName = filename,
+                Arguments = arguments,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true,
+                UseShellExecute = false,
+                CreateNoWindow = true,
+            },
+            EnableRaisingEvents = true
+        };
+
+        if (workingDirectory != null)
+        {
+            process.StartInfo.WorkingDirectory = workingDirectory;
+        }
 
-            dumpDirectoryPath ??= Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
+        dumpDirectoryPath ??= Environment.GetEnvironmentVariable("HELIX_DUMP_FOLDER");
 
-            if (dumpDirectoryPath != null)
-            {
-                process.StartInfo.EnvironmentVariables["COMPlus_DbgEnableMiniDump"] = "1";
-                process.StartInfo.EnvironmentVariables["COMPlus_DbgMiniDumpName"] = Path.Combine(dumpDirectoryPath, $"{Path.GetFileName(filename)}.%d.dmp");
-            }
+        if (dumpDirectoryPath != null)
+        {
+            process.StartInfo.EnvironmentVariables["COMPlus_DbgEnableMiniDump"] = "1";
+            process.StartInfo.EnvironmentVariables["COMPlus_DbgMiniDumpName"] = Path.Combine(dumpDirectoryPath, $"{Path.GetFileName(filename)}.%d.dmp");
+        }
 
-            if (environmentVariables != null)
+        if (environmentVariables != null)
+        {
+            foreach (var kvp in environmentVariables)
             {
-                foreach (var kvp in environmentVariables)
-                {
-                    process.StartInfo.Environment.Add(kvp);
-                }
+                process.StartInfo.Environment.Add(kvp);
             }
+        }
 
-            var outputBuilder = new StringBuilder();
-            process.OutputDataReceived += (_, e) =>
+        var outputBuilder = new StringBuilder();
+        process.OutputDataReceived += (_, e) =>
+        {
+            if (e.Data != null)
             {
-                if (e.Data != null)
+                if (outputDataReceived != null)
                 {
-                    if (outputDataReceived != null)
-                    {
-                        outputDataReceived.Invoke(e.Data);
-                    }
-                    else
-                    {
-                        outputBuilder.AppendLine(e.Data);
-                    }
+                    outputDataReceived.Invoke(e.Data);
                 }
-            };
-
-            var errorBuilder = new StringBuilder();
-            process.ErrorDataReceived += (_, e) =>
-            {
-                if (e.Data != null)
+                else
                 {
-                    if (errorDataReceived != null)
-                    {
-                        errorDataReceived.Invoke(e.Data);
-                    }
-                    else
-                    {
-                        errorBuilder.AppendLine(e.Data);
-                    }
+                    outputBuilder.AppendLine(e.Data);
                 }
-            };
-
-            var processLifetimeTask = new TaskCompletionSource<ProcessResult>();
+            }
+        };
 
-            process.Exited += (_, e) =>
+        var errorBuilder = new StringBuilder();
+        process.ErrorDataReceived += (_, e) =>
+        {
+            if (e.Data != null)
             {
-                Console.WriteLine($"'{process.StartInfo.FileName} {process.StartInfo.Arguments}' completed with exit code '{process.ExitCode}'");
-                if (throwOnError && process.ExitCode != 0)
+                if (errorDataReceived != null)
                 {
-                    processLifetimeTask.TrySetException(new InvalidOperationException($"Command {filename} {arguments} returned exit code {process.ExitCode} output: {outputBuilder.ToString()}"));
+                    errorDataReceived.Invoke(e.Data);
                 }
                 else
                 {
-                    processLifetimeTask.TrySetResult(new ProcessResult(outputBuilder.ToString(), errorBuilder.ToString(), process.ExitCode));
+                    errorBuilder.AppendLine(e.Data);
                 }
-            };
+            }
+        };
 
-            process.Start();
-            onStart?.Invoke(process.Id);
+        var processLifetimeTask = new TaskCompletionSource<ProcessResult>();
 
-            process.BeginOutputReadLine();
-            process.BeginErrorReadLine();
+        process.Exited += (_, e) =>
+        {
+            Console.WriteLine($"'{process.StartInfo.FileName} {process.StartInfo.Arguments}' completed with exit code '{process.ExitCode}'");
+            if (throwOnError && process.ExitCode != 0)
+            {
+                processLifetimeTask.TrySetException(new InvalidOperationException($"Command {filename} {arguments} returned exit code {process.ExitCode} output: {outputBuilder.ToString()}"));
+            }
+            else
+            {
+                processLifetimeTask.TrySetResult(new ProcessResult(outputBuilder.ToString(), errorBuilder.ToString(), process.ExitCode));
+            }
+        };
 
-            var canceledTcs = new TaskCompletionSource<object?>();
-            await using var _ = cancellationToken.Register(() => canceledTcs.TrySetResult(null));
+        process.Start();
+        onStart?.Invoke(process.Id);
 
-            var result = await Task.WhenAny(processLifetimeTask.Task, canceledTcs.Task);
+        process.BeginOutputReadLine();
+        process.BeginErrorReadLine();
 
-            if (result == canceledTcs.Task)
+        var canceledTcs = new TaskCompletionSource<object?>();
+        await using var _ = cancellationToken.Register(() => canceledTcs.TrySetResult(null));
+
+        var result = await Task.WhenAny(processLifetimeTask.Task, canceledTcs.Task);
+
+        if (result == canceledTcs.Task)
+        {
+            if (dumpDirectoryPath != null)
             {
-                if (dumpDirectoryPath != null)
-                {
-                    var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{Path.GetFileName(filename)}.{process.Id}.dmp");
-                    // Capture a process dump if the dumpDirectory is set
-                    await CaptureDumpAsync(process.Id, dumpFilePath);
-                }
+                var dumpFilePath = Path.Combine(dumpDirectoryPath, $"{Path.GetFileName(filename)}.{process.Id}.dmp");
+                // Capture a process dump if the dumpDirectory is set
+                await CaptureDumpAsync(process.Id, dumpFilePath);
+            }
 
-                if (!OperatingSystem.IsWindows())
-                {
-                    sys_kill(process.Id, sig: 2); // SIGINT
+            if (!OperatingSystem.IsWindows())
+            {
+                sys_kill(process.Id, sig: 2); // SIGINT
 
-                    var cancel = new CancellationTokenSource();
+                var cancel = new CancellationTokenSource();
 
-                    await Task.WhenAny(processLifetimeTask.Task, Task.Delay(TimeSpan.FromSeconds(5), cancel.Token));
+                await Task.WhenAny(processLifetimeTask.Task, Task.Delay(TimeSpan.FromSeconds(5), cancel.Token));
 
-                    cancel.Cancel();
-                }
+                cancel.Cancel();
+            }
+
+            if (!process.HasExited)
+            {
+                process.CloseMainWindow();
 
                 if (!process.HasExited)
                 {
-                    process.CloseMainWindow();
-
-                    if (!process.HasExited)
-                    {
-                        process.Kill();
-                    }
+                    process.Kill();
                 }
             }
-
-            return await processLifetimeTask.Task;
         }
+
+        return await processLifetimeTask.Task;
     }
 }