Merge branch 'release/10.0.2xx' into merge/release/10.0.1xx-to-release/10.0.2xx

Author: DonnaChen888

src/Cli/Microsoft.DotNet.FileBasedPrograms/Microsoft.DotNet.FileBasedPrograms.Package.csproj

@@ -12,6 +12,7 @@
 
     <!-- NuGet -->
     <IsPackable>true</IsPackable>
+    <IsShipping>true</IsShipping>
     <IsSourcePackage>true</IsSourcePackage>
     <PackageId>Microsoft.DotNet.FileBasedPrograms</PackageId>
     <IncludeBuildOutput>false</IncludeBuildOutput>

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -378,12 +378,6 @@ For MSTest before 2.2.4, the timeout is used for all testcases.</value>
   <data name="CmdDGFileIOException" xml:space="preserve">
     <value>Unable to generate a temporary file for project '{0}'. Cannot add package reference. Clear the temp directory and try again.</value>
   </data>
-  <data name="CmdDirectoryDescription" xml:space="preserve">
-    <value>Defines the path of directory to run. If not specified, it defaults to the current directory.</value>
-  </data>
-  <data name="CmdDirectoryPathName" xml:space="preserve">
-    <value>DIRECTORY_PATH</value>
-  </data>
   <data name="CmdDisableParallelOptionDescription" xml:space="preserve">
     <value>Prevent restoring multiple projects in parallel.</value>
   </data>
@@ -550,11 +544,13 @@ This is equivalent to deleting project.assets.json.</value>
     <value>Consider packages with prerelease versions when searching for newer packages. Requires the '--outdated' option.</value>
   </data>
   <data name="CmdProjectDescriptionFormat" xml:space="preserve">
-    <value>Defines the path of the project file to {0}. Use path to the project file, or path to the directory containing the project file. If not specified, it defaults to the current directory.</value>
-    <comment>{0} is the verb (e.g., "test", "run")</comment>
+    <value>Defines the path of the project file to run. Use path to the project file, or path to the directory containing the project file. If not specified, it defaults to the current directory.</value>
   </data>
-  <data name="CmdProjectPathName" xml:space="preserve">
-    <value>PROJECT_PATH</value>
+  <data name="CmdProjectOrSolutionDescriptionFormat" xml:space="preserve">
+    <value>Defines the path of the project or solution file to test. Use path to the project file, or path to the directory containing the project file. If not specified, it defaults to the current directory.</value>
+  </data>
+  <data name="CmdProjectOrSolutionPathName" xml:space="preserve">
+    <value>PROJECT_OR_SOLUTION_PATH</value>
   </data>
   <data name="CmdReevaluateOptionDescription" xml:space="preserve">
     <value>Forces restore to reevaluate all dependencies even if a lock file already exists.</value>
@@ -600,12 +596,6 @@ If not specified the file will be generated inside the default 'TestResults' dir
   <data name="CmdSolutionPathName" xml:space="preserve">
     <value>SOLUTION_PATH</value>
   </data>
-  <data name="VerbRun" xml:space="preserve">
-    <value>run</value>
-  </data>
-  <data name="VerbTest" xml:space="preserve">
-    <value>test</value>
-  </data>
   <data name="CmdSourceOption" xml:space="preserve">
     <value>SOURCE</value>
   </data>
@@ -2617,9 +2607,6 @@ Proceed?</value>
   <data name="DotnetTestPipeOverlapping" xml:space="preserve">
     <value>'dotnet' unexpectedly received overlapping messages from the 'dotnet test' named pipe.</value>
   </data>
-  <data name="DotnetTestPipeIncompleteSize" xml:space="preserve">
-    <value>'dotnet' unexpectedly received less than 4 bytes from the 'dotnet test' named pipe.</value>
-  </data>
   <data name="InternalLoopAsyncDidNotExitSuccessfullyErrorMessage" xml:space="preserve">
     <value>Method '{0}' did not exit successfully</value>
   </data>

src/Cli/dotnet/Commands/Run/RunCommandParser.cs

@@ -19,7 +19,7 @@ internal static class RunCommandParser
 
     public static readonly Option<string> ProjectOption = new("--project")
     {
-        Description = string.Format(CliCommandStrings.CmdProjectDescriptionFormat, CliCommandStrings.VerbRun),
+        Description = CliCommandStrings.CmdProjectDescriptionFormat,
         HelpName = CliCommandStrings.CommandOptionProjectHelpName
     };
 

src/Cli/dotnet/Commands/Test/MTP/MSBuildHandler.cs

@@ -16,88 +16,24 @@ internal sealed class MSBuildHandler(BuildOptions buildOptions)
 
     public bool RunMSBuild()
     {
-        if (!ValidationUtility.ValidateBuildPathOptions(_buildOptions))
-        {
-            return false;
-        }
-
-        int msBuildExitCode;
-        string path;
         PathOptions pathOptions = _buildOptions.PathOptions;
 
-        if (!string.IsNullOrEmpty(pathOptions.ProjectPath))
-        {
-            path = PathUtility.GetFullPath(pathOptions.ProjectPath);
-
-            msBuildExitCode = Directory.Exists(path)
-                ? RunBuild(path, expectProject: true)
-                : RunBuild(path, isSolution: false);
-        }
-        else if (!string.IsNullOrEmpty(pathOptions.SolutionPath))
-        {
-            path = PathUtility.GetFullPath(pathOptions.SolutionPath);
-
-            msBuildExitCode = Directory.Exists(path)
-                ? RunBuild(path, expectSolution: true)
-                : RunBuild(path, isSolution: true);
-        }
-        else
+        if (!ValidationUtility.ValidateBuildPathOptions(pathOptions, out string? projectOrSolutionFilePath, out bool isSolution))
         {
-            path = PathUtility.GetFullPath(Directory.GetCurrentDirectory());
-            msBuildExitCode = RunBuild(path);
-        }
-
-        if (msBuildExitCode != ExitCode.Success)
-        {
-            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdMSBuildProjectsPropertiesErrorDescription, msBuildExitCode));
             return false;
         }
 
-        return true;
-    }
-
-    private int RunBuild(string directoryPath, bool expectProject = false, bool expectSolution = false)
-    {
-        bool solutionOrProjectFileFound;
-        string message;
-        string projectOrSolutionFilePath;
-        bool isSolution;
-
-        if (expectProject)
-        {
-            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetProjectFilePath(directoryPath, out projectOrSolutionFilePath);
-            isSolution = false;
-        }
-        else if (expectSolution)
-        {
-            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetSolutionFilePath(directoryPath, out projectOrSolutionFilePath);
-            isSolution = true;
-        }
-        else
-        {
-            (solutionOrProjectFileFound, message) = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(directoryPath, out projectOrSolutionFilePath, out isSolution);
-        }
-
-        if (!solutionOrProjectFileFound)
-        {
-            Reporter.Error.WriteLine(message);
-            return ExitCode.GenericFailure;
-        }
-
         (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> projects, bool restored) = GetProjectsProperties(projectOrSolutionFilePath, isSolution);
 
         InitializeTestApplications(projects);
 
-        return restored && !_testApplications.IsEmpty ? ExitCode.Success : ExitCode.GenericFailure;
-    }
-
-    private int RunBuild(string filePath, bool isSolution)
-    {
-        (IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> projects, bool restored) = GetProjectsProperties(filePath, isSolution);
-
-        InitializeTestApplications(projects);
+        if (!restored || _testApplications.IsEmpty)
+        {
+            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdMSBuildProjectsPropertiesErrorDescription, ExitCode.GenericFailure));
+            return false;
+        }
 
-        return restored && !_testApplications.IsEmpty ? ExitCode.Success : ExitCode.GenericFailure;
+        return true;
     }
 
     private void InitializeTestApplications(IEnumerable<ParallelizableTestModuleGroupWithSequentialInnerModules> moduleGroups)

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

@@ -93,7 +93,7 @@ public static BuildOptions GetBuildOptions(ParseResult parseResult)
         }
 
         PathOptions pathOptions = new(
-            parseResult.GetValue(MicrosoftTestingPlatformOptions.ProjectOption),
+            parseResult.GetValue(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption),
             parseResult.GetValue(MicrosoftTestingPlatformOptions.SolutionOption),
             resultsDirectory,
             configFile,

src/Cli/dotnet/Commands/Test/MTP/MicrosoftTestingPlatformOptions.cs

@@ -7,10 +7,10 @@ namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal static class MicrosoftTestingPlatformOptions
 {
-    public static readonly Option<string> ProjectOption = new("--project")
+    public static readonly Option<string> ProjectOrSolutionOption = new("--project")
     {
-        Description = string.Format(CliCommandStrings.CmdProjectDescriptionFormat, CliCommandStrings.VerbTest),
-        HelpName = CliCommandStrings.CmdProjectPathName,
+        Description = CliCommandStrings.CmdProjectOrSolutionDescriptionFormat,
+        HelpName = CliCommandStrings.CmdProjectOrSolutionPathName,
         Arity = ArgumentArity.ExactlyOne
     };
 

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

@@ -5,7 +5,7 @@ namespace Microsoft.DotNet.Cli.Commands.Test;
 
 internal record TestOptions(bool IsHelp, bool IsDiscovery, IReadOnlyDictionary<string, string> EnvironmentVariables);
 
-internal record PathOptions(string? ProjectPath, string? SolutionPath, string? ResultsDirectoryPath, string? ConfigFilePath, string? DiagnosticOutputDirectoryPath);
+internal record PathOptions(string? ProjectOrSolutionPath, string? SolutionPath, string? ResultsDirectoryPath, string? ConfigFilePath, string? DiagnosticOutputDirectoryPath);
 
 internal record BuildOptions(
     PathOptions PathOptions,

src/Cli/dotnet/Commands/Test/MTP/SolutionAndProjectUtility.cs

@@ -115,31 +115,6 @@ public static (bool SolutionOrProjectFileFound, string Message) TryGetProjectOrS
         return (true, string.Empty);
     }
 
-    public static (bool ProjectFileFound, string Message) TryGetProjectFilePath(string directory, out string projectFilePath)
-    {
-        projectFilePath = string.Empty;
-
-        if (!Directory.Exists(directory))
-        {
-            return (false, string.Format(CliCommandStrings.CmdNonExistentDirectoryErrorDescription, directory));
-        }
-
-        var actualProjectFiles = GetProjectFilePaths(directory);
-
-        if (actualProjectFiles.Length == 0)
-        {
-            return (false, string.Format(CliStrings.CouldNotFindAnyProjectInDirectory, directory));
-        }
-
-        if (actualProjectFiles.Length == 1)
-        {
-            projectFilePath = actualProjectFiles[0];
-            return (true, string.Empty);
-        }
-
-        return (false, string.Format(CliStrings.MoreThanOneProjectInDirectory, directory));
-    }
-
     public static (bool SolutionFileFound, string Message) TryGetSolutionFilePath(string directory, out string solutionFilePath)
     {
         solutionFilePath = string.Empty;

src/Cli/dotnet/Commands/Test/MTP/ValidationUtility.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.DotNet.Cli.Extensions;
 using Microsoft.DotNet.Cli.Utils;
 
@@ -23,7 +24,7 @@ static void ValidatePathOptions(ParseResult parseResult)
             if (parseResult.HasOption(MicrosoftTestingPlatformOptions.SolutionOption))
                 count++;
 
-            if (parseResult.HasOption(MicrosoftTestingPlatformOptions.ProjectOption))
+            if (parseResult.HasOption(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption))
                 count++;
 
             if (count > 1)
@@ -48,18 +49,46 @@ static void ValidateOptionsIrrelevantToModulesFilter(ParseResult parseResult)
         }
     }
 
-    public static bool ValidateBuildPathOptions(BuildOptions buildPathOptions)
+    public static bool ValidateBuildPathOptions(PathOptions pathOptions, [NotNullWhen(true)] out string? projectOrSolutionFilePath, out bool isSolution)
     {
-        PathOptions pathOptions = buildPathOptions.PathOptions;
-
-        if (!string.IsNullOrEmpty(pathOptions.ProjectPath))
+        if (!string.IsNullOrEmpty(pathOptions.ProjectOrSolutionPath))
         {
-            return ValidateProjectPath(pathOptions.ProjectPath);
+            return ValidateProjectOrSolutionPath(pathOptions.ProjectOrSolutionPath, out projectOrSolutionFilePath, out isSolution);
         }
 
         if (!string.IsNullOrEmpty(pathOptions.SolutionPath))
         {
-            return ValidateSolutionPath(pathOptions.SolutionPath);
+            isSolution = true;
+            return ValidateSolutionPath(pathOptions.SolutionPath, out projectOrSolutionFilePath);
+        }
+
+        return TryGetProjectOrSolutionFromDirectory(Directory.GetCurrentDirectory(), onlyConsiderSolutions: false, out projectOrSolutionFilePath, out isSolution);
+    }
+
+    private static bool TryGetProjectOrSolutionFromDirectory(
+        string directory,
+        bool onlyConsiderSolutions,
+        [NotNullWhen(true)] out string? projectOrSolutionFilePath,
+        out bool isSolution)
+    {
+        bool foundSolutionOrProjectInDirectory;
+        string? message;
+        if (onlyConsiderSolutions)
+        {
+            isSolution = true;
+            (foundSolutionOrProjectInDirectory, message) = SolutionAndProjectUtility.TryGetSolutionFilePath(directory, out projectOrSolutionFilePath);
+        }
+        else
+        {
+            (foundSolutionOrProjectInDirectory, message) = SolutionAndProjectUtility.TryGetProjectOrSolutionFilePath(directory, out projectOrSolutionFilePath, out isSolution);
+        }
+
+        if (!foundSolutionOrProjectInDirectory)
+        {
+            Reporter.Error.WriteLine(message);
+            projectOrSolutionFilePath = null;
+            isSolution = false;
+            return false;
         }
 
         return true;
@@ -106,40 +135,47 @@ public static void ValidateSolutionOrProjectOrDirectoryOrModulesArePassedCorrect
         }
     }
 
-    private static bool ValidateSolutionPath(string path)
+    private static bool ValidateSolutionPath(string solutionFileOrDirectory, [NotNullWhen(true)] out string? solutionFile)
     {
         // If it's a directory, just check if it exists
-        if (Directory.Exists(path))
+        if (Directory.Exists(solutionFileOrDirectory))
         {
-            return true;
+            return TryGetProjectOrSolutionFromDirectory(solutionFileOrDirectory, onlyConsiderSolutions: true, out solutionFile, out _);
         }
 
+        solutionFile = solutionFileOrDirectory;
+
         // If it's not a directory, validate as a file path
-        if (!CliConstants.SolutionExtensions.Contains(Path.GetExtension(path)))
+        if (!CliConstants.SolutionExtensions.Contains(Path.GetExtension(solutionFileOrDirectory)))
         {
-            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdInvalidSolutionFileExtensionErrorDescription, path));
+            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdInvalidSolutionFileExtensionErrorDescription, solutionFileOrDirectory));
             return false;
         }
 
-        return ValidateFilePathExists(path);
+        return ValidateFilePathExists(solutionFile);
     }
 
-    private static bool ValidateProjectPath(string path)
+    private static bool ValidateProjectOrSolutionPath(string projectOrSolutionFileOrDirectory, [NotNullWhen(true)] out string? projectOrSolutionFile, out bool isSolution)
     {
         // If it's a directory, just check if it exists
-        if (Directory.Exists(path))
+        if (Directory.Exists(projectOrSolutionFileOrDirectory))
         {
-            return true;
+            return TryGetProjectOrSolutionFromDirectory(projectOrSolutionFileOrDirectory, onlyConsiderSolutions: false, out projectOrSolutionFile, out isSolution);
         }
 
+        var extension = Path.GetExtension(projectOrSolutionFileOrDirectory);
+        isSolution = CliConstants.SolutionExtensions.Contains(extension);
+        projectOrSolutionFile = projectOrSolutionFileOrDirectory;
         // If it's not a directory, validate as a file path
-        if (!Path.GetExtension(path).EndsWith("proj", StringComparison.OrdinalIgnoreCase))
+        if (!isSolution && !extension.EndsWith("proj", StringComparison.OrdinalIgnoreCase))
         {
-            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdInvalidProjectFileExtensionErrorDescription, path));
+            projectOrSolutionFile = null;
+            isSolution = false;
+            Reporter.Error.WriteLine(string.Format(CliCommandStrings.CmdInvalidProjectFileExtensionErrorDescription, projectOrSolutionFileOrDirectory));
             return false;
         }
 
-        return ValidateFilePathExists(path);
+        return ValidateFilePathExists(projectOrSolutionFileOrDirectory);
     }
 
     private static bool ValidateFilePathExists(string filePath)

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

@@ -235,7 +235,7 @@ private static Command GetTestingPlatformCliCommand()
     {
         var command = new MicrosoftTestingPlatformTestCommand("test", CliCommandStrings.DotnetTestCommandMTPDescription);
         command.SetAction(parseResult => command.Run(parseResult));
-        command.Options.Add(MicrosoftTestingPlatformOptions.ProjectOption);
+        command.Options.Add(MicrosoftTestingPlatformOptions.ProjectOrSolutionOption);
         command.Options.Add(MicrosoftTestingPlatformOptions.SolutionOption);
         command.Options.Add(MicrosoftTestingPlatformOptions.TestModulesFilterOption);
         command.Options.Add(MicrosoftTestingPlatformOptions.TestModulesRootDirectoryOption);