Fix build failed due to enabling nullable

v-wuzhai · v-wuzhai · commit 2709f62e1cac · 2024-12-12T22:25:28.000-08:00
diff --git a/test/Microsoft.NET.TestFramework/Assertions/CommandResultAssertions.cs b/test/Microsoft.NET.TestFramework/Assertions/CommandResultAssertions.cs
@@ -47,19 +47,19 @@ public AndConstraint<CommandResultAssertions> HaveStdOut()
 
         public AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut.Equals(expectedOutput, StringComparison.Ordinal))
+            Execute.Assertion.ForCondition(_commandResult.StdOut is not null &&_commandResult.StdOut.Equals(expectedOutput, StringComparison.Ordinal))
                 .FailWith(AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut.Contains(pattern))
+            Execute.Assertion.ForCondition(_commandResult.StdOut is not null && _commandResult.StdOut.Contains(pattern))
                 .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
-        public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string, bool> predicate, string description = "")
+        public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string?, bool> predicate, string description = "")
         {
             Execute.Assertion.ForCondition(predicate(_commandResult.StdOut))
                 .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {description} {Environment.NewLine}"));
@@ -68,7 +68,7 @@ public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string,
 
         public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern, string[]? ignoredPatterns = null)
         {
-            string filteredStdOut = _commandResult.StdOut;
+            string filteredStdOut = _commandResult.StdOut ?? string.Empty;
             if (ignoredPatterns != null && ignoredPatterns.Length > 0)
             {
                 foreach (var ignoredPattern in ignoredPatterns)
@@ -88,7 +88,7 @@ public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pat
 
         public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(string pattern)
         {
-            string commandResultNoSpaces = _commandResult.StdOut.Replace(" ", "");
+            string commandResultNoSpaces = _commandResult.StdOut?.Replace(" ", "") ?? string.Empty;
 
             Execute.Assertion
                 .ForCondition(commandResultNoSpaces.Contains(pattern))
@@ -99,21 +99,21 @@ public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(s
 
         public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreCase(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0)
+            Execute.Assertion.ForCondition(_commandResult.StdOut is not null && _commandResult.StdOut.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0)
                 .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut, pattern, options).Success)
+            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut ?? string.Empty, pattern, options).Success)
                 .FailWith(AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut, pattern, options).Success)
+            Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut ?? string.Empty, pattern, options).Success)
                 .FailWith(AppendDiagnosticsTo($"The command output matched a pattern it should not have. Pattern: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
@@ -127,22 +127,22 @@ public AndConstraint<CommandResultAssertions> HaveStdErr()
 
         public AndConstraint<CommandResultAssertions> HaveStdErr(string expectedOutput)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdErr.Equals(expectedOutput, StringComparison.Ordinal))
+            Execute.Assertion.ForCondition(_commandResult.StdErr is not null && _commandResult.StdErr.Equals(expectedOutput, StringComparison.Ordinal))
                 .FailWith(AppendDiagnosticsTo($"Command did not output the expected output to StdErr.{Environment.NewLine}Expected: {expectedOutput}{Environment.NewLine}Actual:   {_commandResult.StdErr}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdErr.Contains(pattern))
+            Execute.Assertion.ForCondition(_commandResult.StdErr is not null && _commandResult.StdErr.Contains(pattern))
                 .FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErrContainingOnce(string pattern)
         {
-            var lines = _commandResult.StdErr.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
-            var matchingLines = lines.Where(line => line.Contains(pattern)).Count();
+            var lines = _commandResult.StdErr?.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+            var matchingLines = lines?.Where(line => line.Contains(pattern)).Count();
             Execute.Assertion.ForCondition(matchingLines == 0)
                 .FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));
             Execute.Assertion.ForCondition(matchingLines != 1)
@@ -152,14 +152,14 @@ public AndConstraint<CommandResultAssertions> HaveStdErrContainingOnce(string pa
 
         public AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(!_commandResult.StdErr.Contains(pattern))
+            Execute.Assertion.ForCondition(_commandResult.StdErr is not null && !_commandResult.StdErr.Contains(pattern))
                 .FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr, pattern, options).Success)
+            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr ?? string.Empty, pattern, options).Success)
                 .FailWith(AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
diff --git a/test/Microsoft.NET.TestFramework/Commands/MSBuildCommand.cs b/test/Microsoft.NET.TestFramework/Commands/MSBuildCommand.cs
@@ -70,7 +70,7 @@ internal static string FindProjectFile(ref string projectRootPath, string? relat
 
         public virtual DirectoryInfo GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = null, string? platform = null)
         {
-            if (TestAsset != null && platform is not null)
+            if (TestAsset != null)
             {
                 return new DirectoryInfo(OutputPathCalculator.FromProject(ProjectFile, TestAsset).GetOutputDirectory(targetFramework, configuration, runtimeIdentifier, platform));
             }
diff --git a/test/Microsoft.NET.TestFramework/Commands/PublishCommand.cs b/test/Microsoft.NET.TestFramework/Commands/PublishCommand.cs
@@ -24,7 +24,7 @@ public PublishCommand(TestAsset testAsset, string? relativePathToProject = null)
 
         public override DirectoryInfo GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string? platformIdentifier = "")
         {
-            if (TestAsset != null && targetFramework is not null)
+            if (TestAsset != null)
             {
                 return new DirectoryInfo(OutputPathCalculator.FromProject(ProjectFile, TestAsset).GetPublishDirectory(targetFramework, configuration, runtimeIdentifier, platformIdentifier));
             }
diff --git a/test/Microsoft.NET.TestFramework/NuGetTransientErrorDetector.cs b/test/Microsoft.NET.TestFramework/NuGetTransientErrorDetector.cs
@@ -13,9 +13,9 @@ public static class NuGetTransientErrorDetector
             "An error occurred while sending the request"
         };
 
-        public static bool IsTransientError(string errorMessage)
+        public static bool IsTransientError(string? errorMessage)
         {
-            return errorMessage.Contains("NuGet.targets") && _errorSubstrings.Any(errorMessage.Contains);
+            return errorMessage is not null && errorMessage.Contains("NuGet.targets") && _errorSubstrings.Any(errorMessage.Contains);
         }
     }
 }
diff --git a/test/Microsoft.NET.TestFramework/OutputPathCalculator.cs b/test/Microsoft.NET.TestFramework/OutputPathCalculator.cs
@@ -169,7 +169,7 @@ public bool IsMultiTargeted()
             return !string.IsNullOrEmpty(TargetFrameworks);
         }
 
-        public string GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string platform = "")
+        public string GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string? platform = "")
         {
             if (UseArtifactsOutput)
             {
diff --git a/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs b/test/Microsoft.NET.TestFramework/ProjectConstruction/TestProject.cs
@@ -55,7 +55,7 @@ public TestProject([CallerMemberName] string? name = null)
 
         public bool UseArtifactsOutput { get; set; }
 
-        public List<TestProject> ReferencedProjects { get; } = new List<TestProject>();
+        public List<TestProject?> ReferencedProjects { get; } = new List<TestProject?>();
 
         public List<string> References { get; } = new List<string>();
 
@@ -303,7 +303,7 @@ internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder,
                 foreach (var referencedProject in ReferencedProjects)
                 {
                     projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",
-                    new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));
+                    new XAttribute("Include", $"../{referencedProject?.Name}/{referencedProject?.Name}.csproj")));
                 }
             }
 
@@ -419,7 +419,7 @@ static void Main(string[] args)
 
                     foreach (var dependency in ReferencedProjects)
                     {
-                        string? safeDependencyName = dependency.Name?.Replace('.', '_');
+                        string? safeDependencyName = dependency?.Name?.Replace('.', '_');
 
                         source += $"        Console.WriteLine({safeDependencyName}.{safeDependencyName}Class.Name);" + Environment.NewLine;
                         source += $"        Console.WriteLine({safeDependencyName}.{safeDependencyName}Class.List);" + Environment.NewLine;
@@ -448,7 +448,7 @@ public class {safeThisName}Class
 ";
                     foreach (var dependency in ReferencedProjects)
                     {
-                        string? safeDependencyName = dependency.Name?.Replace('.', '_');
+                        string? safeDependencyName = dependency?.Name?.Replace('.', '_');
 
                         source += $"        public string {safeDependencyName}Name {{ get {{ return {safeDependencyName}.{safeDependencyName}Class.Name; }} }}" + Environment.NewLine;
                         source += $"        public List<string> {safeDependencyName}List {{ get {{ return {safeDependencyName}.{safeDependencyName}Class.List; }} }}" + Environment.NewLine;
diff --git a/test/Microsoft.NET.TestFramework/TestAssetsManager.cs b/test/Microsoft.NET.TestFramework/TestAssetsManager.cs
@@ -140,7 +140,10 @@ private TestAsset CreateTestProjectsInDirectory(
 
                     foreach (var referencedProject in project.ReferencedProjects)
                     {
-                        projectStack.Push(referencedProject);
+                        if(referencedProject is not null)
+                        {
+                            projectStack.Push(referencedProject);
+                        }
                     }
                 }
             }
diff --git a/test/Microsoft.NET.TestFramework/ToolsetInfo.cs b/test/Microsoft.NET.TestFramework/ToolsetInfo.cs
@@ -100,7 +100,7 @@ private void InitSdkVersion()
                     throw new Exception("Failed to get dotnet version" + Environment.NewLine + logger.ToString());
                 }
 
-                _sdkVersion = result.StdOut.Trim();
+                _sdkVersion = result.StdOut?.Trim();
             }
             finally
             {
@@ -123,7 +123,7 @@ private void InitMSBuildVersion()
                 throw new Exception("Failed to get msbuild version" + Environment.NewLine + logger.ToString());
             }
 
-            _msbuildVersion = result.StdOut.Split().Last();
+            _msbuildVersion = result.StdOut?.Split().Last();
         }
 
         public string? GetMicrosoftNETBuildExtensionsPath()
diff --git a/test/dotnet-new.Tests/DotnetNewArgumentsTests.cs b/test/dotnet-new.Tests/DotnetNewArgumentsTests.cs
@@ -25,7 +25,7 @@ public void ShowsDetailedOutputOnMissedRequiredParam()
                 .Should()
                 .ExitWith(127)
                 .And.HaveStdErrContaining("Required argument missing for option: '-v'")
-                .And.HaveStdOutContaining(dotnetNewHelpOutput.StdOut);
+                .And.HaveStdOutContaining(dotnetNewHelpOutput.StdOut ?? string.Empty);
         }
     }
 }
diff --git a/test/dotnet-new.Tests/DotnetNewSearchTests.cs b/test/dotnet-new.Tests/DotnetNewSearchTests.cs
@@ -97,7 +97,7 @@ public void ExamplePrefersMicrosoftPackage(string testCase)
             IEnumerable<List<string>> microsoftPackages = tableOutput.Where(row => row[2] == "Microsoft" && row[3].StartsWith("Microsoft", StringComparison.OrdinalIgnoreCase));
             IEnumerable<string> installationCommands = microsoftPackages.Select(package => $"new install {package[3].Split(" /")[0]}").ToList();
 
-            bool ContainsOneOfInstallationCommands(string output) => installationCommands.Any(command => output.Contains(command));
+            bool ContainsOneOfInstallationCommands(string? output) => installationCommands.Any(command => output is not null && output.Contains(command));
             commandResult.Should().HaveStdOutContaining(ContainsOneOfInstallationCommands, "Checks if the output contains one of the expected installation commands");
         }
 
diff --git a/test/dotnet-watch.Tests/MsBuildFileSetFactoryTest.cs b/test/dotnet-watch.Tests/MsBuildFileSetFactoryTest.cs
@@ -422,7 +422,7 @@ private async Task<EvaluationResult> Evaluate(string projectPath)
             return result;
         }
 
-        private static string GetTestProjectPath(TestAsset target) => Path.Combine(GetTestProjectDirectory(target), target.TestProject.Name + ".csproj");
+        private static string GetTestProjectPath(TestAsset target) => Path.Combine(GetTestProjectDirectory(target), target.TestProject?.Name + ".csproj");
 
         private static string WriteFile(TestAsset testAsset, string name, string contents = "")
         {
@@ -443,6 +443,6 @@ private static string WriteFile(TestDirectory testAsset, string name, string con
         }
 
         private static string GetTestProjectDirectory(TestAsset testAsset)
-            => Path.Combine(testAsset.Path, testAsset.TestProject.Name);
+            => Path.Combine(testAsset.Path, testAsset.TestProject?.Name ?? string.Empty);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -47,19 +47,19 @@ public AndConstraint<CommandResultAssertions> HaveStdOut()`
`47`	`47`
`48`	`48`	`public AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)`
`49`	`49`	`{`
`50`		`- Execute.Assertion.ForCondition(_commandResult.StdOut.Equals(expectedOutput, StringComparison.Ordinal))`
	`50`	`+ Execute.Assertion.ForCondition(_commandResult.StdOut is not null &&_commandResult.StdOut.Equals(expectedOutput, StringComparison.Ordinal))`
`51`	`51`	`.FailWith(AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));`
`52`	`52`	`return new AndConstraint<CommandResultAssertions>(this);`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`public AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)`
`56`	`56`	`{`
`57`		`- Execute.Assertion.ForCondition(_commandResult.StdOut.Contains(pattern))`
	`57`	`+ Execute.Assertion.ForCondition(_commandResult.StdOut is not null && _commandResult.StdOut.Contains(pattern))`
`58`	`58`	`.FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));`
`59`	`59`	`return new AndConstraint<CommandResultAssertions>(this);`
`60`	`60`	`}`
`61`	`61`
`62`		`- public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string, bool> predicate, string description = "")`
	`62`	`+ public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string?, bool> predicate, string description = "")`
`63`	`63`	`{`
`64`	`64`	`Execute.Assertion.ForCondition(predicate(_commandResult.StdOut))`
`65`	`65`	`.FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {description} {Environment.NewLine}"));`
`@@ -68,7 +68,7 @@ public AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string,`
`68`	`68`
`69`	`69`	`public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern, string[]? ignoredPatterns = null)`
`70`	`70`	`{`
`71`		`- string filteredStdOut = _commandResult.StdOut;`
	`71`	`+ string filteredStdOut = _commandResult.StdOut ?? string.Empty;`
`72`	`72`	`if (ignoredPatterns != null && ignoredPatterns.Length > 0)`
`73`	`73`	`{`
`74`	`74`	`foreach (var ignoredPattern in ignoredPatterns)`
`@@ -88,7 +88,7 @@ public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pat`
`88`	`88`
`89`	`89`	`public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(string pattern)`
`90`	`90`	`{`
`91`		`- string commandResultNoSpaces = _commandResult.StdOut.Replace(" ", "");`
	`91`	`+ string commandResultNoSpaces = _commandResult.StdOut?.Replace(" ", "") ?? string.Empty;`
`92`	`92`
`93`	`93`	`Execute.Assertion`
`94`	`94`	`.ForCondition(commandResultNoSpaces.Contains(pattern))`
`@@ -99,21 +99,21 @@ public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(s`
`99`	`99`
`100`	`100`	`public AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreCase(string pattern)`
`101`	`101`	`{`
`102`		`- Execute.Assertion.ForCondition(_commandResult.StdOut.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0)`
	`102`	`+ Execute.Assertion.ForCondition(_commandResult.StdOut is not null && _commandResult.StdOut.IndexOf(pattern, StringComparison.OrdinalIgnoreCase) >= 0)`
`103`	`103`	`.FailWith(AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));`
`104`	`104`	`return new AndConstraint<CommandResultAssertions>(this);`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`public AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`108`	`108`	`{`
`109`		`- Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut, pattern, options).Success)`
	`109`	`+ Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut ?? string.Empty, pattern, options).Success)`
`110`	`110`	`.FailWith(AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));`
`111`	`111`	`return new AndConstraint<CommandResultAssertions>(this);`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`public AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`115`	`115`	`{`
`116`		`- Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut, pattern, options).Success)`
	`116`	`+ Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut ?? string.Empty, pattern, options).Success)`
`117`	`117`	`.FailWith(AppendDiagnosticsTo($"The command output matched a pattern it should not have. Pattern: {pattern}{Environment.NewLine}"));`
`118`	`118`	`return new AndConstraint<CommandResultAssertions>(this);`
`119`	`119`	`}`
`@@ -127,22 +127,22 @@ public AndConstraint<CommandResultAssertions> HaveStdErr()`
`127`	`127`
`128`	`128`	`public AndConstraint<CommandResultAssertions> HaveStdErr(string expectedOutput)`
`129`	`129`	`{`
`130`		`- Execute.Assertion.ForCondition(_commandResult.StdErr.Equals(expectedOutput, StringComparison.Ordinal))`
	`130`	`+ Execute.Assertion.ForCondition(_commandResult.StdErr is not null && _commandResult.StdErr.Equals(expectedOutput, StringComparison.Ordinal))`
`131`	`131`	`.FailWith(AppendDiagnosticsTo($"Command did not output the expected output to StdErr.{Environment.NewLine}Expected: {expectedOutput}{Environment.NewLine}Actual: {_commandResult.StdErr}"));`
`132`	`132`	`return new AndConstraint<CommandResultAssertions>(this);`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`public AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)`
`136`	`136`	`{`
`137`		`- Execute.Assertion.ForCondition(_commandResult.StdErr.Contains(pattern))`
	`137`	`+ Execute.Assertion.ForCondition(_commandResult.StdErr is not null && _commandResult.StdErr.Contains(pattern))`
`138`	`138`	`.FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));`
`139`	`139`	`return new AndConstraint<CommandResultAssertions>(this);`
`140`	`140`	`}`
`141`	`141`
`142`	`142`	`public AndConstraint<CommandResultAssertions> HaveStdErrContainingOnce(string pattern)`
`143`	`143`	`{`
`144`		`- var lines = _commandResult.StdErr.Split(new[] { Environment.NewLine }, StringSplitOptions.None);`
`145`		`- var matchingLines = lines.Where(line => line.Contains(pattern)).Count();`
	`144`	`+ var lines = _commandResult.StdErr?.Split(new[] { Environment.NewLine }, StringSplitOptions.None);`
	`145`	`+ var matchingLines = lines?.Where(line => line.Contains(pattern)).Count();`
`146`	`146`	`Execute.Assertion.ForCondition(matchingLines == 0)`
`147`	`147`	`.FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));`
`148`	`148`	`Execute.Assertion.ForCondition(matchingLines != 1)`
`@@ -152,14 +152,14 @@ public AndConstraint<CommandResultAssertions> HaveStdErrContainingOnce(string pa`
`152`	`152`
`153`	`153`	`public AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)`
`154`	`154`	`{`
`155`		`- Execute.Assertion.ForCondition(!_commandResult.StdErr.Contains(pattern))`
	`155`	`+ Execute.Assertion.ForCondition(_commandResult.StdErr is not null && !_commandResult.StdErr.Contains(pattern))`
`156`	`156`	`.FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));`
`157`	`157`	`return new AndConstraint<CommandResultAssertions>(this);`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`public AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)`
`161`	`161`	`{`
`162`		`- Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr, pattern, options).Success)`
	`162`	`+ Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr ?? string.Empty, pattern, options).Success)`
`163`	`163`	`.FailWith(AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));`
`164`	`164`	`return new AndConstraint<CommandResultAssertions>(this);`
`165`	`165`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ internal static string FindProjectFile(ref string projectRootPath, string? relat`
`70`	`70`
`71`	`71`	`public virtual DirectoryInfo GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = null, string? platform = null)`
`72`	`72`	`{`
`73`		`- if (TestAsset != null && platform is not null)`
	`73`	`+ if (TestAsset != null)`
`74`	`74`	`{`
`75`	`75`	`return new DirectoryInfo(OutputPathCalculator.FromProject(ProjectFile, TestAsset).GetOutputDirectory(targetFramework, configuration, runtimeIdentifier, platform));`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public PublishCommand(TestAsset testAsset, string? relativePathToProject = null)`
`24`	`24`
`25`	`25`	`public override DirectoryInfo GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string? platformIdentifier = "")`
`26`	`26`	`{`
`27`		`- if (TestAsset != null && targetFramework is not null)`
	`27`	`+ if (TestAsset != null)`
`28`	`28`	`{`
`29`	`29`	`return new DirectoryInfo(OutputPathCalculator.FromProject(ProjectFile, TestAsset).GetPublishDirectory(targetFramework, configuration, runtimeIdentifier, platformIdentifier));`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,9 @@ public static class NuGetTransientErrorDetector`
`13`	`13`	`"An error occurred while sending the request"`
`14`	`14`	`};`
`15`	`15`
`16`		`- public static bool IsTransientError(string errorMessage)`
	`16`	`+ public static bool IsTransientError(string? errorMessage)`
`17`	`17`	`{`
`18`		`- return errorMessage.Contains("NuGet.targets") && _errorSubstrings.Any(errorMessage.Contains);`
	`18`	`+ return errorMessage is not null && errorMessage.Contains("NuGet.targets") && _errorSubstrings.Any(errorMessage.Contains);`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -169,7 +169,7 @@ public bool IsMultiTargeted()`
`169`	`169`	`return !string.IsNullOrEmpty(TargetFrameworks);`
`170`	`170`	`}`
`171`	`171`
`172`		`- public string GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string platform = "")`
	`172`	`+ public string GetOutputDirectory(string? targetFramework = null, string configuration = "Debug", string? runtimeIdentifier = "", string? platform = "")`
`173`	`173`	`{`
`174`	`174`	`if (UseArtifactsOutput)`
`175`	`175`	`{`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public TestProject([CallerMemberName] string? name = null)`
`55`	`55`
`56`	`56`	`public bool UseArtifactsOutput { get; set; }`
`57`	`57`
`58`		`- public List<TestProject> ReferencedProjects { get; } = new List<TestProject>();`
	`58`	`+ public List<TestProject?> ReferencedProjects { get; } = new List<TestProject?>();`
`59`	`59`
`60`	`60`	`public List<string> References { get; } = new List<string>();`
`61`	`61`
`@@ -303,7 +303,7 @@ internal void Create(TestAsset targetTestAsset, string testProjectsSourceFolder,`
`303`	`303`	`foreach (var referencedProject in ReferencedProjects)`
`304`	`304`	`{`
`305`	`305`	`projectReferenceItemGroup.Add(new XElement(ns + "ProjectReference",`
`306`		`- new XAttribute("Include", $"../{referencedProject.Name}/{referencedProject.Name}.csproj")));`
	`306`	`+ new XAttribute("Include", $"../{referencedProject?.Name}/{referencedProject?.Name}.csproj")));`
`307`	`307`	`}`
`308`	`308`	`}`
`309`	`309`
`@@ -419,7 +419,7 @@ static void Main(string[] args)`
`419`	`419`
`420`	`420`	`foreach (var dependency in ReferencedProjects)`
`421`	`421`	`{`
`422`		`- string? safeDependencyName = dependency.Name?.Replace('.', '_');`
	`422`	`+ string? safeDependencyName = dependency?.Name?.Replace('.', '_');`
`423`	`423`
`424`	`424`	`source += $" Console.WriteLine({safeDependencyName}.{safeDependencyName}Class.Name);" + Environment.NewLine;`
`425`	`425`	`source += $" Console.WriteLine({safeDependencyName}.{safeDependencyName}Class.List);" + Environment.NewLine;`
`@@ -448,7 +448,7 @@ public class {safeThisName}Class`
`448`	`448`	`";`
`449`	`449`	`foreach (var dependency in ReferencedProjects)`
`450`	`450`	`{`
`451`		`- string? safeDependencyName = dependency.Name?.Replace('.', '_');`
	`451`	`+ string? safeDependencyName = dependency?.Name?.Replace('.', '_');`
`452`	`452`
`453`	`453`	`source += $" public string {safeDependencyName}Name {{ get {{ return {safeDependencyName}.{safeDependencyName}Class.Name; }} }}" + Environment.NewLine;`
`454`	`454`	`source += $" public List<string> {safeDependencyName}List {{ get {{ return {safeDependencyName}.{safeDependencyName}Class.List; }} }}" + Environment.NewLine;`
Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,10 @@ private TestAsset CreateTestProjectsInDirectory(`
`140`	`140`
`141`	`141`	`foreach (var referencedProject in project.ReferencedProjects)`
`142`	`142`	`{`
`143`		`- projectStack.Push(referencedProject);`
	`143`	`+ if(referencedProject is not null)`
	`144`	`+ {`
	`145`	`+ projectStack.Push(referencedProject);`
	`146`	`+ }`
`144`	`147`	`}`
`145`	`148`	`}`
`146`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ private void InitSdkVersion()`
`100`	`100`	`throw new Exception("Failed to get dotnet version" + Environment.NewLine + logger.ToString());`
`101`	`101`	`}`
`102`	`102`
`103`		`- _sdkVersion = result.StdOut.Trim();`
	`103`	`+ _sdkVersion = result.StdOut?.Trim();`
`104`	`104`	`}`
`105`	`105`	`finally`
`106`	`106`	`{`
`@@ -123,7 +123,7 @@ private void InitMSBuildVersion()`
`123`	`123`	`throw new Exception("Failed to get msbuild version" + Environment.NewLine + logger.ToString());`
`124`	`124`	`}`
`125`	`125`
`126`		`- _msbuildVersion = result.StdOut.Split().Last();`
	`126`	`+ _msbuildVersion = result.StdOut?.Split().Last();`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`public string? GetMicrosoftNETBuildExtensionsPath()`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public void ShowsDetailedOutputOnMissedRequiredParam()`
`25`	`25`	`.Should()`
`26`	`26`	`.ExitWith(127)`
`27`	`27`	`.And.HaveStdErrContaining("Required argument missing for option: '-v'")`
`28`		`- .And.HaveStdOutContaining(dotnetNewHelpOutput.StdOut);`
	`28`	`+ .And.HaveStdOutContaining(dotnetNewHelpOutput.StdOut ?? string.Empty);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ public void ExamplePrefersMicrosoftPackage(string testCase)`
`97`	`97`	`IEnumerable<List<string>> microsoftPackages = tableOutput.Where(row => row[2] == "Microsoft" && row[3].StartsWith("Microsoft", StringComparison.OrdinalIgnoreCase));`
`98`	`98`	`IEnumerable<string> installationCommands = microsoftPackages.Select(package => $"new install {package[3].Split(" /")[0]}").ToList();`
`99`	`99`
`100`		`- bool ContainsOneOfInstallationCommands(string output) => installationCommands.Any(command => output.Contains(command));`
	`100`	`+ bool ContainsOneOfInstallationCommands(string? output) => installationCommands.Any(command => output is not null && output.Contains(command));`
`101`	`101`	`commandResult.Should().HaveStdOutContaining(ContainsOneOfInstallationCommands, "Checks if the output contains one of the expected installation commands");`
`102`	`102`	`}`
`103`	`103`