Implement global --config-file and --diagnostic-output-directory options for dotnet test MTP

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -565,6 +565,37 @@ This is equivalent to deleting project.assets.json.</value>
     <value>The directory where the test results will be placed.
 The specified directory will be created if it does not exist.</value>
   </data>
+  <data name="CmdConfigFileDescription" xml:space="preserve">
+    <value>The NuGet configuration file to use for the test execution.</value>
+  </data>
+  <data name="CmdConfigFilePath" xml:space="preserve">
+    <value>CONFIG_FILE</value>
+  </data>
+  <data name="CmdDiagnosticOutputDirectoryDescription" xml:space="preserve">
+    <value>The directory where diagnostic output will be placed.
+The specified directory will be created if it does not exist.</value>
+  </data>
+  <data name="CmdDiagnosticOutputDirectoryPath" xml:space="preserve">
+    <value>DIAGNOSTIC_DIR</value>
+  </data>
+  <data name="CmdTimeoutDescription" xml:space="preserve">
+    <value>The timeout for the test execution in milliseconds.</value>
+  </data>
+  <data name="CmdTimeoutValue" xml:space="preserve">
+    <value>TIMEOUT</value>
+  </data>
+  <data name="CmdMinimumExpectedTestsDescription" xml:space="preserve">
+    <value>The minimum number of tests expected to be discovered.</value>
+  </data>
+  <data name="CmdMinimumExpectedTestsValue" xml:space="preserve">
+    <value>COUNT</value>
+  </data>
+  <data name="CmdMaximumFailedTestsDescription" xml:space="preserve">
+    <value>The maximum number of tests allowed to fail before the test run is terminated.</value>
+  </data>
+  <data name="CmdMaximumFailedTestsValue" xml:space="preserve">
+    <value>COUNT</value>
+  </data>
   <data name="CmdRootPathName" xml:space="preserve">
     <value>ROOT_PATH</value>
   </data>

src/Cli/dotnet/Commands/Test/MSBuildUtility.cs

@@ -69,14 +69,28 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
         string? resultsDirectory = parseResult.GetValue(TestingPlatformOptions.ResultsDirectoryOption);
         if (resultsDirectory is not null)
         {
-            resultsDirectory = Path.Combine(Directory.GetCurrentDirectory(), resultsDirectory);
+            resultsDirectory = Path.GetFullPath(resultsDirectory);
+        }
+
+        string? configFile = parseResult.GetValue(TestingPlatformOptions.ConfigFileOption);
+        if (configFile is not null)
+        {
+            configFile = Path.GetFullPath(configFile);
+        }
+
+        string? diagnosticOutputDirectory = parseResult.GetValue(TestingPlatformOptions.DiagnosticOutputDirectoryOption);
+        if (diagnosticOutputDirectory is not null)
+        {
+            diagnosticOutputDirectory = Path.GetFullPath(diagnosticOutputDirectory);
         }
 
         PathOptions pathOptions = new(
             parseResult.GetValue(TestingPlatformOptions.ProjectOption),
             parseResult.GetValue(TestingPlatformOptions.SolutionOption),
             parseResult.GetValue(TestingPlatformOptions.DirectoryOption),
-            resultsDirectory);
+            resultsDirectory,
+            configFile,
+            diagnosticOutputDirectory);
 
         return new BuildOptions(
             pathOptions,
@@ -87,7 +101,10 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult, int degreeOf
             parseResult.GetValue(TestingPlatformOptions.NoLaunchProfileArgumentsOption),
             degreeOfParallelism,
             otherArgs,
-            msbuildArgs);
+            msbuildArgs,
+            parseResult.GetValue(TestingPlatformOptions.TimeoutOption),
+            parseResult.GetValue(TestingPlatformOptions.MinimumExpectedTestsOption),
+            parseResult.GetValue(TestingPlatformOptions.MaximumFailedTestsOption));
     }
 
     private static bool BuildOrRestoreProjectOrSolution(string filePath, BuildOptions buildOptions)

src/Cli/dotnet/Commands/Test/Options.cs

@@ -5,7 +5,7 @@ namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal record TestOptions(bool HasFilterMode, bool IsHelp);
 
-internal record PathOptions(string? ProjectPath, string? SolutionPath, string? DirectoryPath, string? ResultsDirectoryPath);
+internal record PathOptions(string? ProjectPath, string? SolutionPath, string? DirectoryPath, string? ResultsDirectoryPath, string? ConfigFilePath, string? DiagnosticOutputDirectoryPath);
 
 internal record BuildOptions(
     PathOptions PathOptions,
@@ -14,5 +14,9 @@ internal record BuildOptions(
     Utils.VerbosityOptions? Verbosity,
     bool NoLaunchProfile,
     bool NoLaunchProfileArguments,
-    int DegreeOfParallelism, List<string> UnmatchedTokens,
-    IEnumerable<string> MSBuildArgs);
+    int DegreeOfParallelism, 
+    List<string> UnmatchedTokens,
+    IEnumerable<string> MSBuildArgs,
+    string? Timeout,
+    string? MinimumExpectedTests,
+    string? MaximumFailedTests);

src/Cli/dotnet/Commands/Test/TestApplication.cs

@@ -115,6 +115,31 @@ private string GetArguments(TestOptions testOptions)
             builder.Append($" {TestingPlatformOptions.ResultsDirectoryOption.Name} {ArgumentEscaper.EscapeSingleArg(resultsDirectoryPath)}");
         }
 
+        if (_buildOptions.PathOptions.ConfigFilePath is { } configFilePath)
+        {
+            builder.Append($" {TestingPlatformOptions.ConfigFileOption.Name} {ArgumentEscaper.EscapeSingleArg(configFilePath)}");
+        }
+
+        if (_buildOptions.PathOptions.DiagnosticOutputDirectoryPath is { } diagnosticOutputDirectoryPath)
+        {
+            builder.Append($" {TestingPlatformOptions.DiagnosticOutputDirectoryOption.Name} {ArgumentEscaper.EscapeSingleArg(diagnosticOutputDirectoryPath)}");
+        }
+
+        if (_buildOptions.Timeout is { } timeout)
+        {
+            builder.Append($" {TestingPlatformOptions.TimeoutOption.Name} {ArgumentEscaper.EscapeSingleArg(timeout)}");
+        }
+
+        if (_buildOptions.MinimumExpectedTests is { } minimumExpectedTests)
+        {
+            builder.Append($" {TestingPlatformOptions.MinimumExpectedTestsOption.Name} {ArgumentEscaper.EscapeSingleArg(minimumExpectedTests)}");
+        }
+
+        if (_buildOptions.MaximumFailedTests is { } maximumFailedTests)
+        {
+            builder.Append($" {TestingPlatformOptions.MaximumFailedTestsOption.Name} {ArgumentEscaper.EscapeSingleArg(maximumFailedTests)}");
+        }
+
         foreach (var arg in _buildOptions.UnmatchedTokens)
         {
             builder.Append($" {ArgumentEscaper.EscapeSingleArg(arg)}");

src/Cli/dotnet/Commands/Test/TestCommandParser.cs

@@ -236,6 +236,11 @@ private static Command GetTestingPlatformCliCommand()
         command.Options.Add(TestingPlatformOptions.TestModulesFilterOption);
         command.Options.Add(TestingPlatformOptions.TestModulesRootDirectoryOption);
         command.Options.Add(TestingPlatformOptions.ResultsDirectoryOption);
+        command.Options.Add(TestingPlatformOptions.ConfigFileOption);
+        command.Options.Add(TestingPlatformOptions.DiagnosticOutputDirectoryOption);
+        command.Options.Add(TestingPlatformOptions.TimeoutOption);
+        command.Options.Add(TestingPlatformOptions.MinimumExpectedTestsOption);
+        command.Options.Add(TestingPlatformOptions.MaximumFailedTestsOption);
         command.Options.Add(TestingPlatformOptions.MaxParallelTestModulesOption);
         command.Options.Add(CommonOptions.ArchitectureOption);
         command.Options.Add(CommonOptions.PropertiesOption);

src/Cli/dotnet/Commands/Test/TestingPlatformOptions.cs

@@ -50,6 +50,41 @@ internal static class TestingPlatformOptions
         Arity = ArgumentArity.ExactlyOne
     };
 
+    public static readonly Option<string> ConfigFileOption = new("--config-file")
+    {
+        Description = CliCommandStrings.CmdConfigFileDescription,
+        HelpName = CliCommandStrings.CmdConfigFilePath,
+        Arity = ArgumentArity.ExactlyOne
+    };
+
+    public static readonly Option<string> DiagnosticOutputDirectoryOption = new("--diagnostic-output-directory")
+    {
+        Description = CliCommandStrings.CmdDiagnosticOutputDirectoryDescription,
+        HelpName = CliCommandStrings.CmdDiagnosticOutputDirectoryPath,
+        Arity = ArgumentArity.ExactlyOne
+    };
+
+    public static readonly Option<string> TimeoutOption = new("--timeout")
+    {
+        Description = CliCommandStrings.CmdTimeoutDescription,
+        HelpName = CliCommandStrings.CmdTimeoutValue,
+        Arity = ArgumentArity.ExactlyOne
+    };
+
+    public static readonly Option<string> MinimumExpectedTestsOption = new("--minimum-expected-tests")
+    {
+        Description = CliCommandStrings.CmdMinimumExpectedTestsDescription,
+        HelpName = CliCommandStrings.CmdMinimumExpectedTestsValue,
+        Arity = ArgumentArity.ExactlyOne
+    };
+
+    public static readonly Option<string> MaximumFailedTestsOption = new("--maximum-failed-tests")
+    {
+        Description = CliCommandStrings.CmdMaximumFailedTestsDescription,
+        HelpName = CliCommandStrings.CmdMaximumFailedTestsValue,
+        Arity = ArgumentArity.ExactlyOne
+    };
+
     public static readonly Option<string> MaxParallelTestModulesOption = new("--max-parallel-test-modules")
     {
         Description = CliCommandStrings.CmdMaxParallelTestModulesDescription,