Switch to AwesomeAssertions (#113425)

ericstj · web-flow · commit 96b80da6e184 · 2025-03-17T13:18:04.000-07:00
* Switch to AwesomeAssertions

* React to brekaing API changes
diff --git a/eng/Versions.props b/eng/Versions.props
@@ -201,7 +201,7 @@
     <NewtonsoftJsonBsonVersion>1.0.2</NewtonsoftJsonBsonVersion>
     <SQLitePCLRawbundle_greenVersion>2.0.4</SQLitePCLRawbundle_greenVersion>
     <MoqVersion>4.18.4</MoqVersion>
-    <FluentAssertionsVersion>6.7.0</FluentAssertionsVersion>
+    <AwesomeAssertionsVersion>8.0.2</AwesomeAssertionsVersion>
     <FsCheckVersion>2.14.3</FsCheckVersion>
     <CommandLineParserVersion>2.9.1</CommandLineParserVersion>
     <!-- Android gRPC client tests -->
diff --git a/src/installer/tests/HostActivation.Tests/DependencyResolution/DependencyResolutionCommandResultExtensions.cs b/src/installer/tests/HostActivation.Tests/DependencyResolution/DependencyResolutionCommandResultExtensions.cs
@@ -18,10 +18,11 @@ public static class DependencyResolutionCommandResultExtensions
         public static AndConstraint<CommandResultAssertions> HaveRuntimePropertyContaining(this CommandResultAssertions assertion, string propertyName, params string[] values)
         {
             string propertyValue = GetAppMockPropertyValue(assertion, propertyName);
+            AssertionChain assertionChain = AssertionChain.GetOrCreate();
 
             foreach (string value in values)
             {
-                Execute.Assertion.ForCondition(propertyValue != null && propertyValue.Contains(value))
+                assertionChain.ForCondition(propertyValue != null && propertyValue.Contains(value))
                     .FailWith($"The property {propertyName} doesn't contain expected value: '{value}'{Environment.NewLine}" +
                         $"{propertyName}='{propertyValue}'" +
                         $"{assertion.GetDiagnosticsInfo()}");
@@ -33,10 +34,11 @@ public static AndConstraint<CommandResultAssertions> HaveRuntimePropertyContaini
         public static AndConstraint<CommandResultAssertions> NotHaveRuntimePropertyContaining(this CommandResultAssertions assertion, string propertyName, params string[] values)
         {
             string propertyValue = GetAppMockPropertyValue(assertion, propertyName);
+            AssertionChain assertionChain = AssertionChain.GetOrCreate();
 
             foreach (string value in values)
             {
-                Execute.Assertion.ForCondition(propertyValue != null && !propertyValue.Contains(value))
+                assertionChain.ForCondition(propertyValue != null && !propertyValue.Contains(value))
                     .FailWith($"The property {propertyName} contains unexpected value: '{value}'{Environment.NewLine}" +
                         $"{propertyName}='{propertyValue}'" +
                         $"{assertion.GetDiagnosticsInfo()}");
@@ -80,10 +82,11 @@ public static AndConstraint<CommandResultAssertions> HaveResolvedComponentDepend
             params string[] values)
         {
             string propertyValue = GetComponentMockPropertyValue(assertion, propertyName);
+            AssertionChain assertionChain = AssertionChain.GetOrCreate();
 
             foreach (string value in values)
             {
-                Execute.Assertion.ForCondition(propertyValue != null && propertyValue.Contains(value))
+                assertionChain.ForCondition(propertyValue != null && propertyValue.Contains(value))
                     .FailWith($"The resolved {propertyName} doesn't contain expected value: '{value}'{Environment.NewLine}" +
                         $"{propertyName}='{propertyValue}'" +
                         $"{assertion.GetDiagnosticsInfo()}");
@@ -98,10 +101,11 @@ public static AndConstraint<CommandResultAssertions> NotHaveResolvedComponentDep
             params string[] values)
         {
             string propertyValue = GetComponentMockPropertyValue(assertion, propertyName);
+            AssertionChain assertionChain = AssertionChain.GetOrCreate();
 
             foreach (string value in values)
             {
-                Execute.Assertion.ForCondition(propertyValue != null && !propertyValue.Contains(value))
+                assertionChain.ForCondition(propertyValue != null && !propertyValue.Contains(value))
                     .FailWith($"The resolved {propertyName} contains unexpected value: '{value}'{Environment.NewLine}" +
                         $"{propertyName}='{propertyValue}'" +
                         $"{assertion.GetDiagnosticsInfo()}");
diff --git a/src/installer/tests/TestUtils/Assertions/CommandResultAssertions.cs b/src/installer/tests/TestUtils/Assertions/CommandResultAssertions.cs
@@ -14,9 +14,12 @@ public class CommandResultAssertions
     {
         public CommandResult Result { get; }
 
-        public CommandResultAssertions(CommandResult commandResult)
+        public AssertionChain CurrentAssertionChain { get; }
+
+        public CommandResultAssertions(CommandResult commandResult, AssertionChain assertionChain)
         {
             Result = commandResult;
+            CurrentAssertionChain = assertionChain;
         }
 
         public AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)
@@ -25,128 +28,128 @@ public AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)
             if (!OperatingSystem.IsWindows())
                 expectedExitCode = expectedExitCode & 0xFF;
 
-            Execute.Assertion.ForCondition(Result.ExitCode == expectedExitCode)
+            CurrentAssertionChain.ForCondition(Result.ExitCode == expectedExitCode)
                 .FailWith($"Expected command to exit with {expectedExitCode} but it did not.{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> Pass()
         {
-            Execute.Assertion.ForCondition(Result.ExitCode == 0)
+            CurrentAssertionChain.ForCondition(Result.ExitCode == 0)
                 .FailWith($"Expected command to pass but it did not.{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> Fail()
         {
-            Execute.Assertion.ForCondition(Result.ExitCode != 0)
+            CurrentAssertionChain.ForCondition(Result.ExitCode != 0)
                 .FailWith($"Expected command to fail but it did not.{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOut()
         {
-            Execute.Assertion.ForCondition(!string.IsNullOrEmpty(Result.StdOut))
+            CurrentAssertionChain.ForCondition(!string.IsNullOrEmpty(Result.StdOut))
                 .FailWith($"Command did not output anything to stdout{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)
         {
-            Execute.Assertion.ForCondition(Result.StdOut.Equals(expectedOutput, StringComparison.Ordinal))
+            CurrentAssertionChain.ForCondition(Result.StdOut.Equals(expectedOutput, StringComparison.Ordinal))
                 .FailWith($"Command did not output with Expected Output. Expected: '{expectedOutput}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(Result.StdOut.Contains(pattern))
+            CurrentAssertionChain.ForCondition(Result.StdOut.Contains(pattern))
                 .FailWith($"The command output did not contain expected result: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(!Result.StdOut.Contains(pattern))
+            CurrentAssertionChain.ForCondition(!Result.StdOut.Contains(pattern))
                 .FailWith($"The command output contained a result it should not have contained: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.IsMatch(Result.StdOut, pattern, options))
+            CurrentAssertionChain.ForCondition(Regex.IsMatch(Result.StdOut, pattern, options))
                 .FailWith($"Matching the command output failed. Pattern: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(!Regex.IsMatch(Result.StdOut, pattern, options))
+            CurrentAssertionChain.ForCondition(!Regex.IsMatch(Result.StdOut, pattern, options))
                 .FailWith($"The command output matched a pattern is should not have matched. Pattern: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErr()
         {
-            Execute.Assertion.ForCondition(!string.IsNullOrEmpty(Result.StdErr))
+            CurrentAssertionChain.ForCondition(!string.IsNullOrEmpty(Result.StdErr))
                 .FailWith($"Command did not output anything to stderr.{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(Result.StdErr.Contains(pattern))
+            CurrentAssertionChain.ForCondition(Result.StdErr.Contains(pattern))
                 .FailWith($"The command error output did not contain expected result: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(!Result.StdErr.Contains(pattern))
+            CurrentAssertionChain.ForCondition(!Result.StdErr.Contains(pattern))
                 .FailWith($"The command error output contained a result it should not have contained: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.IsMatch(Result.StdErr, pattern, options))
+            CurrentAssertionChain.ForCondition(Regex.IsMatch(Result.StdErr, pattern, options))
                 .FailWith($"Matching the command error output failed. Pattern: '{pattern}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdOut()
         {
-            Execute.Assertion.ForCondition(string.IsNullOrEmpty(Result.StdOut))
+            CurrentAssertionChain.ForCondition(string.IsNullOrEmpty(Result.StdOut))
                 .FailWith($"Expected command to not output to stdout but it did:{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotHaveStdErr()
         {
-            Execute.Assertion.ForCondition(string.IsNullOrEmpty(Result.StdErr))
+            CurrentAssertionChain.ForCondition(string.IsNullOrEmpty(Result.StdErr))
                 .FailWith($"Expected command to not output to stderr but it did:{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> FileExists(string path)
         {
-            Execute.Assertion.ForCondition(System.IO.File.Exists(path))
+            CurrentAssertionChain.ForCondition(System.IO.File.Exists(path))
                 .FailWith($"The command did not write the expected file: '{path}'{GetDiagnosticsInfo()}");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> FileContains(string path, string pattern)
         {
             string fileContent = System.IO.File.ReadAllText(path);
-            Execute.Assertion.ForCondition(fileContent.Contains(pattern))
+            CurrentAssertionChain.ForCondition(fileContent.Contains(pattern))
                 .FailWith($"The command did not write the expected result '{pattern}' to the file: '{path}'{GetDiagnosticsInfo()}{Environment.NewLine}file content: >>{fileContent}<<");
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         public AndConstraint<CommandResultAssertions> NotFileContains(string path, string pattern)
         {
             string fileContent = System.IO.File.ReadAllText(path);
-            Execute.Assertion.ForCondition(!fileContent.Contains(pattern))
+            CurrentAssertionChain.ForCondition(!fileContent.Contains(pattern))
                 .FailWith($"The command did not write the expected result '{pattern}' to the file: '{path}'{GetDiagnosticsInfo()}{Environment.NewLine}file content: >>{fileContent}<<");
             return new AndConstraint<CommandResultAssertions>(this);
         }
diff --git a/src/installer/tests/TestUtils/Assertions/CommandResultExtensions.cs b/src/installer/tests/TestUtils/Assertions/CommandResultExtensions.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using FluentAssertions;
+using FluentAssertions.Execution;
 using Microsoft.DotNet.Cli.Build.Framework;
 using System;
 
@@ -11,13 +12,13 @@ public static class CommandResultExtensions
     {
         public static CommandResultAssertions Should(this CommandResult commandResult)
         {
-            return new CommandResultAssertions(commandResult);
+            return new CommandResultAssertions(commandResult, AssertionChain.GetOrCreate());
         }
 
         public static CommandResult StdErrAfter(this CommandResult commandResult, string pattern)
         {
             int i = commandResult.StdErr.IndexOf(pattern);
-            i.Should().BeGreaterOrEqualTo(
+            i.Should().BeGreaterThanOrEqualTo(
                 0,
                 "Trying to filter StdErr after '{0}', but such string can't be found in the StdErr.{1}{2}",
                 pattern,
diff --git a/src/installer/tests/TestUtils/Assertions/DirectoryInfoAssertions.cs b/src/installer/tests/TestUtils/Assertions/DirectoryInfoAssertions.cs
@@ -13,33 +13,35 @@ namespace Microsoft.DotNet.CoreSetup.Test
     public class DirectoryInfoAssertions
     {
         private DirectoryInfo _dirInfo;
+        private AssertionChain _assertionChain;
 
-        public DirectoryInfoAssertions(DirectoryInfo dir)
+        public DirectoryInfoAssertions(DirectoryInfo dir, AssertionChain assertionChain)
         {
             _dirInfo = dir;
+            _assertionChain = assertionChain;
         }
 
         public DirectoryInfo DirectoryInfo => _dirInfo;
 
         public AndConstraint<DirectoryInfoAssertions> Exist()
         {
-            Execute.Assertion.ForCondition(_dirInfo.Exists)
+            _assertionChain.ForCondition(_dirInfo.Exists)
                 .FailWith($"Expected directory '{_dirInfo.FullName}' does not exist.");
             return new AndConstraint<DirectoryInfoAssertions>(this);
         }
 
         public AndConstraint<DirectoryInfoAssertions> HaveFile(string expectedFile)
         {
             var file = _dirInfo.EnumerateFiles(expectedFile, SearchOption.TopDirectoryOnly).SingleOrDefault();
-            Execute.Assertion.ForCondition(file != null)
+            _assertionChain.ForCondition(file != null)
                 .FailWith($"Expected File '{expectedFile}' cannot be found in directory '{_dirInfo.FullName}.");
             return new AndConstraint<DirectoryInfoAssertions>(this);
         }
 
         public AndConstraint<DirectoryInfoAssertions> NotHaveFile(string expectedFile)
         {
             var file = _dirInfo.EnumerateFiles(expectedFile, SearchOption.TopDirectoryOnly).SingleOrDefault();
-            Execute.Assertion.ForCondition(file == null)
+            _assertionChain.ForCondition(file == null)
                 .FailWith($"File '{expectedFile}' should not be found in directory '{_dirInfo.FullName}'.");
             return new AndConstraint<DirectoryInfoAssertions>(this);
         }
@@ -67,19 +69,19 @@ public AndConstraint<DirectoryInfoAssertions> NotHaveFiles(IEnumerable<string> e
         public AndConstraint<DirectoryInfoAssertions> HaveDirectory(string expectedDir)
         {
             var dir = _dirInfo.EnumerateDirectories(expectedDir, SearchOption.TopDirectoryOnly).SingleOrDefault();
-            Execute.Assertion.ForCondition(dir != null)
+            _assertionChain.ForCondition(dir != null)
                 .FailWith($"Expected directory '{expectedDir}' cannot be found inside directory '{_dirInfo.FullName}'.");
 
-            return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir));
+            return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir, _assertionChain));
         }
 
         public AndConstraint<DirectoryInfoAssertions> NotHaveDirectory(string expectedDir)
         {
             var dir = _dirInfo.EnumerateDirectories(expectedDir, SearchOption.TopDirectoryOnly).SingleOrDefault();
-            Execute.Assertion.ForCondition(dir == null)
+            _assertionChain.ForCondition(dir == null)
                 .FailWith($"Directory '{expectedDir}' should not be found in found inside directory '{_dirInfo.FullName}'.");
 
-            return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir));
+            return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir, _assertionChain));
         }
 
         public AndConstraint<DirectoryInfoAssertions> OnlyHaveFiles(IEnumerable<string> expectedFiles)
@@ -89,10 +91,10 @@ public AndConstraint<DirectoryInfoAssertions> OnlyHaveFiles(IEnumerable<string>
             var extraFiles = Enumerable.Except(actualFiles, expectedFiles);
             var nl = Environment.NewLine;
 
-            Execute.Assertion.ForCondition(!missingFiles.Any())
+            _assertionChain.ForCondition(!missingFiles.Any())
                 .FailWith($"Following files cannot be found inside directory {_dirInfo.FullName} {nl} {string.Join(nl, missingFiles)}");
 
-            Execute.Assertion.ForCondition(!extraFiles.Any())
+            _assertionChain.ForCondition(!extraFiles.Any())
                 .FailWith($"Following extra files are found inside directory {_dirInfo.FullName} {nl} {string.Join(nl, extraFiles)}");
 
             return new AndConstraint<DirectoryInfoAssertions>(this);
@@ -103,7 +105,7 @@ public AndConstraint<DirectoryInfoAssertions> NotBeModifiedAfter(DateTime timeUt
             _dirInfo.Refresh();
             DateTime writeTime = _dirInfo.LastWriteTimeUtc;
 
-            Execute.Assertion.ForCondition(writeTime <= timeUtc)
+            _assertionChain.ForCondition(writeTime <= timeUtc)
                 .FailWith($"Directory '{_dirInfo.FullName}' should not be modified after {timeUtc}, but is modified at {writeTime}.");
 
             return new AndConstraint<DirectoryInfoAssertions>(this);
diff --git a/src/installer/tests/TestUtils/Assertions/DirectoryInfoExtensions.cs b/src/installer/tests/TestUtils/Assertions/DirectoryInfoExtensions.cs
@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using FluentAssertions.Execution;
 using System.IO;
 
 namespace Microsoft.DotNet.CoreSetup.Test
@@ -9,7 +10,7 @@ public static class DirectoryInfoExtensions
     {
         public static DirectoryInfoAssertions Should(this DirectoryInfo dir)
         {
-            return new DirectoryInfoAssertions(dir);
+            return new DirectoryInfoAssertions(dir, AssertionChain.GetOrCreate());
         }
     }
 }
diff --git a/src/installer/tests/TestUtils/TestUtils.csproj b/src/installer/tests/TestUtils/TestUtils.csproj
@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="FluentAssertions" Version="$(FluentAssertionsVersion)" />
+    <PackageReference Include="AwesomeAssertions" Version="$(AwesomeAssertionsVersion)" />
     <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsVersion)" />
     <PackageReference Include="xunit.core" Version="$(XUnitVersion)" ExcludeAssets="build" />
     <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelVersion)" />
diff --git a/src/libraries/Microsoft.Extensions.DependencyModel/tests/JsonAssetions.cs b/src/libraries/Microsoft.Extensions.DependencyModel/tests/JsonAssetions.cs
diff --git a/src/libraries/Microsoft.Extensions.DependencyModel/tests/Microsoft.Extensions.DependencyModel.Tests.csproj b/src/libraries/Microsoft.Extensions.DependencyModel/tests/Microsoft.Extensions.DependencyModel.Tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -14,9 +14,12 @@ public class CommandResultAssertions`
`14`	`14`	`{`
`15`	`15`	`public CommandResult Result { get; }`
`16`	`16`
`17`		`- public CommandResultAssertions(CommandResult commandResult)`
	`17`	`+ public AssertionChain CurrentAssertionChain { get; }`
	`18`	`+`
	`19`	`+ public CommandResultAssertions(CommandResult commandResult, AssertionChain assertionChain)`
`18`	`20`	`{`
`19`	`21`	`Result = commandResult;`
	`22`	`+ CurrentAssertionChain = assertionChain;`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`public AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)`
`@@ -25,128 +28,128 @@ public AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)`
`25`	`28`	`if (!OperatingSystem.IsWindows())`
`26`	`29`	`expectedExitCode = expectedExitCode & 0xFF;`
`27`	`30`
`28`		`- Execute.Assertion.ForCondition(Result.ExitCode == expectedExitCode)`
	`31`	`+ CurrentAssertionChain.ForCondition(Result.ExitCode == expectedExitCode)`
`29`	`32`	`.FailWith($"Expected command to exit with {expectedExitCode} but it did not.{GetDiagnosticsInfo()}");`
`30`	`33`	`return new AndConstraint<CommandResultAssertions>(this);`
`31`	`34`	`}`
`32`	`35`
`33`	`36`	`public AndConstraint<CommandResultAssertions> Pass()`
`34`	`37`	`{`
`35`		`- Execute.Assertion.ForCondition(Result.ExitCode == 0)`
	`38`	`+ CurrentAssertionChain.ForCondition(Result.ExitCode == 0)`
`36`	`39`	`.FailWith($"Expected command to pass but it did not.{GetDiagnosticsInfo()}");`
`37`	`40`	`return new AndConstraint<CommandResultAssertions>(this);`
`38`	`41`	`}`
`39`	`42`
`40`	`43`	`public AndConstraint<CommandResultAssertions> Fail()`
`41`	`44`	`{`
`42`		`- Execute.Assertion.ForCondition(Result.ExitCode != 0)`
	`45`	`+ CurrentAssertionChain.ForCondition(Result.ExitCode != 0)`
`43`	`46`	`.FailWith($"Expected command to fail but it did not.{GetDiagnosticsInfo()}");`
`44`	`47`	`return new AndConstraint<CommandResultAssertions>(this);`
`45`	`48`	`}`
`46`	`49`
`47`	`50`	`public AndConstraint<CommandResultAssertions> HaveStdOut()`
`48`	`51`	`{`
`49`		`- Execute.Assertion.ForCondition(!string.IsNullOrEmpty(Result.StdOut))`
	`52`	`+ CurrentAssertionChain.ForCondition(!string.IsNullOrEmpty(Result.StdOut))`
`50`	`53`	`.FailWith($"Command did not output anything to stdout{GetDiagnosticsInfo()}");`
`51`	`54`	`return new AndConstraint<CommandResultAssertions>(this);`
`52`	`55`	`}`
`53`	`56`
`54`	`57`	`public AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)`
`55`	`58`	`{`
`56`		`- Execute.Assertion.ForCondition(Result.StdOut.Equals(expectedOutput, StringComparison.Ordinal))`
	`59`	`+ CurrentAssertionChain.ForCondition(Result.StdOut.Equals(expectedOutput, StringComparison.Ordinal))`
`57`	`60`	`.FailWith($"Command did not output with Expected Output. Expected: '{expectedOutput}'{GetDiagnosticsInfo()}");`
`58`	`61`	`return new AndConstraint<CommandResultAssertions>(this);`
`59`	`62`	`}`
`60`	`63`
`61`	`64`	`public AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)`
`62`	`65`	`{`
`63`		`- Execute.Assertion.ForCondition(Result.StdOut.Contains(pattern))`
	`66`	`+ CurrentAssertionChain.ForCondition(Result.StdOut.Contains(pattern))`
`64`	`67`	`.FailWith($"The command output did not contain expected result: '{pattern}'{GetDiagnosticsInfo()}");`
`65`	`68`	`return new AndConstraint<CommandResultAssertions>(this);`
`66`	`69`	`}`
`67`	`70`
`68`	`71`	`public AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern)`
`69`	`72`	`{`
`70`		`- Execute.Assertion.ForCondition(!Result.StdOut.Contains(pattern))`
	`73`	`+ CurrentAssertionChain.ForCondition(!Result.StdOut.Contains(pattern))`
`71`	`74`	`.FailWith($"The command output contained a result it should not have contained: '{pattern}'{GetDiagnosticsInfo()}");`
`72`	`75`	`return new AndConstraint<CommandResultAssertions>(this);`
`73`	`76`	`}`
`74`	`77`
`75`	`78`	`public AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`76`	`79`	`{`
`77`		`- Execute.Assertion.ForCondition(Regex.IsMatch(Result.StdOut, pattern, options))`
	`80`	`+ CurrentAssertionChain.ForCondition(Regex.IsMatch(Result.StdOut, pattern, options))`
`78`	`81`	`.FailWith($"Matching the command output failed. Pattern: '{pattern}'{GetDiagnosticsInfo()}");`
`79`	`82`	`return new AndConstraint<CommandResultAssertions>(this);`
`80`	`83`	`}`
`81`	`84`
`82`	`85`	`public AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`83`	`86`	`{`
`84`		`- Execute.Assertion.ForCondition(!Regex.IsMatch(Result.StdOut, pattern, options))`
	`87`	`+ CurrentAssertionChain.ForCondition(!Regex.IsMatch(Result.StdOut, pattern, options))`
`85`	`88`	`.FailWith($"The command output matched a pattern is should not have matched. Pattern: '{pattern}'{GetDiagnosticsInfo()}");`
`86`	`89`	`return new AndConstraint<CommandResultAssertions>(this);`
`87`	`90`	`}`
`88`	`91`
`89`	`92`	`public AndConstraint<CommandResultAssertions> HaveStdErr()`
`90`	`93`	`{`
`91`		`- Execute.Assertion.ForCondition(!string.IsNullOrEmpty(Result.StdErr))`
	`94`	`+ CurrentAssertionChain.ForCondition(!string.IsNullOrEmpty(Result.StdErr))`
`92`	`95`	`.FailWith($"Command did not output anything to stderr.{GetDiagnosticsInfo()}");`
`93`	`96`	`return new AndConstraint<CommandResultAssertions>(this);`
`94`	`97`	`}`
`95`	`98`
`96`	`99`	`public AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)`
`97`	`100`	`{`
`98`		`- Execute.Assertion.ForCondition(Result.StdErr.Contains(pattern))`
	`101`	`+ CurrentAssertionChain.ForCondition(Result.StdErr.Contains(pattern))`
`99`	`102`	`.FailWith($"The command error output did not contain expected result: '{pattern}'{GetDiagnosticsInfo()}");`
`100`	`103`	`return new AndConstraint<CommandResultAssertions>(this);`
`101`	`104`	`}`
`102`	`105`
`103`	`106`	`public AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)`
`104`	`107`	`{`
`105`		`- Execute.Assertion.ForCondition(!Result.StdErr.Contains(pattern))`
	`108`	`+ CurrentAssertionChain.ForCondition(!Result.StdErr.Contains(pattern))`
`106`	`109`	`.FailWith($"The command error output contained a result it should not have contained: '{pattern}'{GetDiagnosticsInfo()}");`
`107`	`110`	`return new AndConstraint<CommandResultAssertions>(this);`
`108`	`111`	`}`
`109`	`112`
`110`	`113`	`public AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)`
`111`	`114`	`{`
`112`		`- Execute.Assertion.ForCondition(Regex.IsMatch(Result.StdErr, pattern, options))`
	`115`	`+ CurrentAssertionChain.ForCondition(Regex.IsMatch(Result.StdErr, pattern, options))`
`113`	`116`	`.FailWith($"Matching the command error output failed. Pattern: '{pattern}'{GetDiagnosticsInfo()}");`
`114`	`117`	`return new AndConstraint<CommandResultAssertions>(this);`
`115`	`118`	`}`
`116`	`119`
`117`	`120`	`public AndConstraint<CommandResultAssertions> NotHaveStdOut()`
`118`	`121`	`{`
`119`		`- Execute.Assertion.ForCondition(string.IsNullOrEmpty(Result.StdOut))`
	`122`	`+ CurrentAssertionChain.ForCondition(string.IsNullOrEmpty(Result.StdOut))`
`120`	`123`	`.FailWith($"Expected command to not output to stdout but it did:{GetDiagnosticsInfo()}");`
`121`	`124`	`return new AndConstraint<CommandResultAssertions>(this);`
`122`	`125`	`}`
`123`	`126`
`124`	`127`	`public AndConstraint<CommandResultAssertions> NotHaveStdErr()`
`125`	`128`	`{`
`126`		`- Execute.Assertion.ForCondition(string.IsNullOrEmpty(Result.StdErr))`
	`129`	`+ CurrentAssertionChain.ForCondition(string.IsNullOrEmpty(Result.StdErr))`
`127`	`130`	`.FailWith($"Expected command to not output to stderr but it did:{GetDiagnosticsInfo()}");`
`128`	`131`	`return new AndConstraint<CommandResultAssertions>(this);`
`129`	`132`	`}`
`130`	`133`
`131`	`134`	`public AndConstraint<CommandResultAssertions> FileExists(string path)`
`132`	`135`	`{`
`133`		`- Execute.Assertion.ForCondition(System.IO.File.Exists(path))`
	`136`	`+ CurrentAssertionChain.ForCondition(System.IO.File.Exists(path))`
`134`	`137`	`.FailWith($"The command did not write the expected file: '{path}'{GetDiagnosticsInfo()}");`
`135`	`138`	`return new AndConstraint<CommandResultAssertions>(this);`
`136`	`139`	`}`
`137`	`140`
`138`	`141`	`public AndConstraint<CommandResultAssertions> FileContains(string path, string pattern)`
`139`	`142`	`{`
`140`	`143`	`string fileContent = System.IO.File.ReadAllText(path);`
`141`		`- Execute.Assertion.ForCondition(fileContent.Contains(pattern))`
	`144`	`+ CurrentAssertionChain.ForCondition(fileContent.Contains(pattern))`
`142`	`145`	`.FailWith($"The command did not write the expected result '{pattern}' to the file: '{path}'{GetDiagnosticsInfo()}{Environment.NewLine}file content: >>{fileContent}<<");`
`143`	`146`	`return new AndConstraint<CommandResultAssertions>(this);`
`144`	`147`	`}`
`145`	`148`
`146`	`149`	`public AndConstraint<CommandResultAssertions> NotFileContains(string path, string pattern)`
`147`	`150`	`{`
`148`	`151`	`string fileContent = System.IO.File.ReadAllText(path);`
`149`		`- Execute.Assertion.ForCondition(!fileContent.Contains(pattern))`
	`152`	`+ CurrentAssertionChain.ForCondition(!fileContent.Contains(pattern))`
`150`	`153`	`.FailWith($"The command did not write the expected result '{pattern}' to the file: '{path}'{GetDiagnosticsInfo()}{Environment.NewLine}file content: >>{fileContent}<<");`
`151`	`154`	`return new AndConstraint<CommandResultAssertions>(this);`
`152`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using FluentAssertions;`
	`5`	`+using FluentAssertions.Execution;`
`5`	`6`	`using Microsoft.DotNet.Cli.Build.Framework;`
`6`	`7`	`using System;`
`7`	`8`
`@@ -11,13 +12,13 @@ public static class CommandResultExtensions`
`11`	`12`	`{`
`12`	`13`	`public static CommandResultAssertions Should(this CommandResult commandResult)`
`13`	`14`	`{`
`14`		`- return new CommandResultAssertions(commandResult);`
	`15`	`+ return new CommandResultAssertions(commandResult, AssertionChain.GetOrCreate());`
`15`	`16`	`}`
`16`	`17`
`17`	`18`	`public static CommandResult StdErrAfter(this CommandResult commandResult, string pattern)`
`18`	`19`	`{`
`19`	`20`	`int i = commandResult.StdErr.IndexOf(pattern);`
`20`		`- i.Should().BeGreaterOrEqualTo(`
	`21`	`+ i.Should().BeGreaterThanOrEqualTo(`
`21`	`22`	`0,`
`22`	`23`	`"Trying to filter StdErr after '{0}', but such string can't be found in the StdErr.{1}{2}",`
`23`	`24`	`pattern,`
Original file line number	Diff line number	Diff line change
`@@ -13,33 +13,35 @@ namespace Microsoft.DotNet.CoreSetup.Test`
`13`	`13`	`public class DirectoryInfoAssertions`
`14`	`14`	`{`
`15`	`15`	`private DirectoryInfo _dirInfo;`
	`16`	`+ private AssertionChain _assertionChain;`
`16`	`17`
`17`		`- public DirectoryInfoAssertions(DirectoryInfo dir)`
	`18`	`+ public DirectoryInfoAssertions(DirectoryInfo dir, AssertionChain assertionChain)`
`18`	`19`	`{`
`19`	`20`	`_dirInfo = dir;`
	`21`	`+ _assertionChain = assertionChain;`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`public DirectoryInfo DirectoryInfo => _dirInfo;`
`23`	`25`
`24`	`26`	`public AndConstraint<DirectoryInfoAssertions> Exist()`
`25`	`27`	`{`
`26`		`- Execute.Assertion.ForCondition(_dirInfo.Exists)`
	`28`	`+ _assertionChain.ForCondition(_dirInfo.Exists)`
`27`	`29`	`.FailWith($"Expected directory '{_dirInfo.FullName}' does not exist.");`
`28`	`30`	`return new AndConstraint<DirectoryInfoAssertions>(this);`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`public AndConstraint<DirectoryInfoAssertions> HaveFile(string expectedFile)`
`32`	`34`	`{`
`33`	`35`	`var file = _dirInfo.EnumerateFiles(expectedFile, SearchOption.TopDirectoryOnly).SingleOrDefault();`
`34`		`- Execute.Assertion.ForCondition(file != null)`
	`36`	`+ _assertionChain.ForCondition(file != null)`
`35`	`37`	`.FailWith($"Expected File '{expectedFile}' cannot be found in directory '{_dirInfo.FullName}.");`
`36`	`38`	`return new AndConstraint<DirectoryInfoAssertions>(this);`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`public AndConstraint<DirectoryInfoAssertions> NotHaveFile(string expectedFile)`
`40`	`42`	`{`
`41`	`43`	`var file = _dirInfo.EnumerateFiles(expectedFile, SearchOption.TopDirectoryOnly).SingleOrDefault();`
`42`		`- Execute.Assertion.ForCondition(file == null)`
	`44`	`+ _assertionChain.ForCondition(file == null)`
`43`	`45`	`.FailWith($"File '{expectedFile}' should not be found in directory '{_dirInfo.FullName}'.");`
`44`	`46`	`return new AndConstraint<DirectoryInfoAssertions>(this);`
`45`	`47`	`}`
`@@ -67,19 +69,19 @@ public AndConstraint<DirectoryInfoAssertions> NotHaveFiles(IEnumerable<string> e`
`67`	`69`	`public AndConstraint<DirectoryInfoAssertions> HaveDirectory(string expectedDir)`
`68`	`70`	`{`
`69`	`71`	`var dir = _dirInfo.EnumerateDirectories(expectedDir, SearchOption.TopDirectoryOnly).SingleOrDefault();`
`70`		`- Execute.Assertion.ForCondition(dir != null)`
	`72`	`+ _assertionChain.ForCondition(dir != null)`
`71`	`73`	`.FailWith($"Expected directory '{expectedDir}' cannot be found inside directory '{_dirInfo.FullName}'.");`
`72`	`74`
`73`		`- return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir));`
	`75`	`+ return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir, _assertionChain));`
`74`	`76`	`}`
`75`	`77`
`76`	`78`	`public AndConstraint<DirectoryInfoAssertions> NotHaveDirectory(string expectedDir)`
`77`	`79`	`{`
`78`	`80`	`var dir = _dirInfo.EnumerateDirectories(expectedDir, SearchOption.TopDirectoryOnly).SingleOrDefault();`
`79`		`- Execute.Assertion.ForCondition(dir == null)`
	`81`	`+ _assertionChain.ForCondition(dir == null)`
`80`	`82`	`.FailWith($"Directory '{expectedDir}' should not be found in found inside directory '{_dirInfo.FullName}'.");`
`81`	`83`
`82`		`- return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir));`
	`84`	`+ return new AndConstraint<DirectoryInfoAssertions>(new DirectoryInfoAssertions(dir, _assertionChain));`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`public AndConstraint<DirectoryInfoAssertions> OnlyHaveFiles(IEnumerable<string> expectedFiles)`
`@@ -89,10 +91,10 @@ public AndConstraint<DirectoryInfoAssertions> OnlyHaveFiles(IEnumerable<string>`
`89`	`91`	`var extraFiles = Enumerable.Except(actualFiles, expectedFiles);`
`90`	`92`	`var nl = Environment.NewLine;`
`91`	`93`
`92`		`- Execute.Assertion.ForCondition(!missingFiles.Any())`
	`94`	`+ _assertionChain.ForCondition(!missingFiles.Any())`
`93`	`95`	`.FailWith($"Following files cannot be found inside directory {_dirInfo.FullName} {nl} {string.Join(nl, missingFiles)}");`
`94`	`96`
`95`		`- Execute.Assertion.ForCondition(!extraFiles.Any())`
	`97`	`+ _assertionChain.ForCondition(!extraFiles.Any())`
`96`	`98`	`.FailWith($"Following extra files are found inside directory {_dirInfo.FullName} {nl} {string.Join(nl, extraFiles)}");`
`97`	`99`
`98`	`100`	`return new AndConstraint<DirectoryInfoAssertions>(this);`
`@@ -103,7 +105,7 @@ public AndConstraint<DirectoryInfoAssertions> NotBeModifiedAfter(DateTime timeUt`
`103`	`105`	`_dirInfo.Refresh();`
`104`	`106`	`DateTime writeTime = _dirInfo.LastWriteTimeUtc;`
`105`	`107`
`106`		`- Execute.Assertion.ForCondition(writeTime <= timeUtc)`
	`108`	`+ _assertionChain.ForCondition(writeTime <= timeUtc)`
`107`	`109`	`.FailWith($"Directory '{_dirInfo.FullName}' should not be modified after {timeUtc}, but is modified at {writeTime}.");`
`108`	`110`
`109`	`111`	`return new AndConstraint<DirectoryInfoAssertions>(this);`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`// Licensed to the .NET Foundation under one or more agreements.`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
	`4`	`+using FluentAssertions.Execution;`
`4`	`5`	`using System.IO;`
`5`	`6`
`6`	`7`	`namespace Microsoft.DotNet.CoreSetup.Test`
`@@ -9,7 +10,7 @@ public static class DirectoryInfoExtensions`
`9`	`10`	`{`
`10`	`11`	`public static DirectoryInfoAssertions Should(this DirectoryInfo dir)`
`11`	`12`	`{`
`12`		`- return new DirectoryInfoAssertions(dir);`
	`13`	`+ return new DirectoryInfoAssertions(dir, AssertionChain.GetOrCreate());`
`13`	`14`	`}`
`14`	`15`	`}`
`15`	`16`	`}`