Replace FluentAssertions with AwesomeAssertions (#596)

JanProvaznik · web-flow · commit a0b838590bdb · 2025-04-22T11:46:01.000+02:00
diff --git a/tests/Install-Scripts.Test/Install-Scripts.Test.csproj b/tests/Install-Scripts.Test/Install-Scripts.Test.csproj
@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
-	  <PackageReference Include="FluentAssertions" Version="5.10.3" />
+	  <PackageReference Include="AwesomeAssertions" Version="8.0.2" />
 	  <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
 	  <PackageReference Include="Verify.Xunit" Version="19.10.0" />
 	  <PackageReference Include="xunit" Version="2.4.2" />
diff --git a/tests/Install-Scripts.Test/Utils/CommandResultAssertions.cs b/tests/Install-Scripts.Test/Utils/CommandResultAssertions.cs
@@ -5,7 +5,7 @@
 using System.Text.RegularExpressions;
 using FluentAssertions;
 using FluentAssertions.Execution;
-using static Install_Scripts.Test.Utils.DotNetCommand;
+using CommandResult = Install_Scripts.Test.Utils.DotNetCommand.CommandResult;
 
 namespace Microsoft.NET.TestFramework.Assertions
 {
@@ -20,145 +20,122 @@ internal CommandResultAssertions(CommandResult commandResult)
 
         internal AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)
         {
-            Execute.Assertion.ForCondition(_commandResult.ExitCode == expectedExitCode)
-                .FailWith(AppendDiagnosticsTo($"Expected command to exit with {expectedExitCode} but it did not."));
+            _commandResult.ExitCode.Should().Be(expectedExitCode, AppendDiagnosticsTo($"Expected command to exit with {expectedExitCode} but it did not."));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> Pass()
         {
-            Execute.Assertion.ForCondition(_commandResult.ExitCode == 0)
-                .FailWith(AppendDiagnosticsTo($"Expected command to pass but it did not."));
+            _commandResult.ExitCode.Should().Be(0, AppendDiagnosticsTo($"Expected command to pass but it did not."));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> Fail()
         {
-            Execute.Assertion.ForCondition(_commandResult.ExitCode != 0)
-                .FailWith(AppendDiagnosticsTo($"Expected command to fail but it did not."));
+            _commandResult.ExitCode.Should().NotBe(0, AppendDiagnosticsTo($"Expected command to fail but it did not."));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOut()
         {
-            Execute.Assertion.ForCondition(!string.IsNullOrEmpty(_commandResult.StdOut))
-                .FailWith(AppendDiagnosticsTo("Command did not output anything to stdout"));
+            _commandResult.StdOut.Should().NotBeNullOrEmpty(AppendDiagnosticsTo("Command did not output anything to stdout"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut!.Equals(expectedOutput, StringComparison.Ordinal))
-                .FailWith(AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));
+            _commandResult.StdOut.Should().Be(expectedOutput, AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut!.Contains(pattern))
-                .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().Contain(pattern, AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal 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}"));
+            predicate(_commandResult.StdOut!).Should().BeTrue(AppendDiagnosticsTo($"The command output did not contain expected result: {description} {Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(!_commandResult.StdOut!.Contains(pattern))
-                .FailWith(AppendDiagnosticsTo($"The command output contained a result it should not have contained: {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().NotContain(pattern, AppendDiagnosticsTo($"The command output contained a result it should not have contained: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdOutContainingIgnoreCase(string pattern)
         {
-            Execute.Assertion.ForCondition(!_commandResult.StdOut!.Contains(pattern, StringComparison.OrdinalIgnoreCase))
-                .FailWith(AppendDiagnosticsTo($"The command output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().NotContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(string pattern)
         {
-            string commandResultNoSpaces = _commandResult.StdOut!.Replace(" ", "");
-
-            Execute.Assertion
-                .ForCondition(commandResultNoSpaces.Contains(pattern))
-                .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));
-
+            var commandResultNoSpaces = _commandResult.StdOut!.Replace(" ", "");
+            commandResultNoSpaces.Should().Contain(pattern, AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreCase(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdOut!.Contains(pattern, StringComparison.OrdinalIgnoreCase))
-                .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().ContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut!, pattern, options).Success)
-                .FailWith(AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().MatchRegex(pattern, AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut!, pattern, options).Success)
-                .FailWith(AppendDiagnosticsTo($"The command output matched a pattern it should not have. Pattern: {pattern}{Environment.NewLine}"));
+            _commandResult.StdOut.Should().NotMatchRegex(pattern, AppendDiagnosticsTo($"The command output matched a pattern it should not have contained: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdErr()
         {
-            Execute.Assertion.ForCondition(!string.IsNullOrEmpty(_commandResult.StdErr))
-                .FailWith(AppendDiagnosticsTo("Command did not output anything to stderr."));
+            _commandResult.StdErr.Should().NotBeNullOrEmpty(AppendDiagnosticsTo("Command did not output anything to stderr."));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(_commandResult.StdErr!.Contains(pattern))
-                .FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));
+            _commandResult.StdErr.Should().Contain(pattern, AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)
         {
-            Execute.Assertion.ForCondition(!_commandResult.StdErr!.Contains(pattern))
-                .FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));
+            _commandResult.StdErr.Should().NotContain(pattern, AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdErrContainingIgnoreCase(string pattern)
         {
-            Execute.Assertion.ForCondition(!_commandResult.StdErr!.Contains(pattern, StringComparison.OrdinalIgnoreCase))
-                .FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));
+            _commandResult.StdErr.Should().NotContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command error output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)
         {
-            Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr!, pattern, options).Success)
-                .FailWith(AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));
+            _commandResult.StdErr.Should().MatchRegex(pattern, AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdOut()
         {
-            Execute.Assertion.ForCondition(string.IsNullOrEmpty(_commandResult.StdOut))
-                .FailWith(AppendDiagnosticsTo($"Expected command to not output to stdout but it did:"));
+            _commandResult.StdOut.Should().BeNullOrEmpty(AppendDiagnosticsTo($"Expected command to not output to stdout but it did:"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 
         internal AndConstraint<CommandResultAssertions> NotHaveStdErr()
         {
-            Execute.Assertion.ForCondition(string.IsNullOrEmpty(_commandResult.StdErr))
-                .FailWith(AppendDiagnosticsTo("Expected command to not output to stderr but it did:"));
+            _commandResult.StdErr.Should().BeNullOrEmpty(AppendDiagnosticsTo("Expected command to not output to stderr but it did:"));
             return new AndConstraint<CommandResultAssertions>(this);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`using System.Text.RegularExpressions;`
`6`	`6`	`using FluentAssertions;`
`7`	`7`	`using FluentAssertions.Execution;`
`8`		`-using static Install_Scripts.Test.Utils.DotNetCommand;`
	`8`	`+using CommandResult = Install_Scripts.Test.Utils.DotNetCommand.CommandResult;`
`9`	`9`
`10`	`10`	`namespace Microsoft.NET.TestFramework.Assertions`
`11`	`11`	`{`
`@@ -20,145 +20,122 @@ internal CommandResultAssertions(CommandResult commandResult)`
`20`	`20`
`21`	`21`	`internal AndConstraint<CommandResultAssertions> ExitWith(int expectedExitCode)`
`22`	`22`	`{`
`23`		`- Execute.Assertion.ForCondition(_commandResult.ExitCode == expectedExitCode)`
`24`		`- .FailWith(AppendDiagnosticsTo($"Expected command to exit with {expectedExitCode} but it did not."));`
	`23`	`+ _commandResult.ExitCode.Should().Be(expectedExitCode, AppendDiagnosticsTo($"Expected command to exit with {expectedExitCode} but it did not."));`
`25`	`24`	`return new AndConstraint<CommandResultAssertions>(this);`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`internal AndConstraint<CommandResultAssertions> Pass()`
`29`	`28`	`{`
`30`		`- Execute.Assertion.ForCondition(_commandResult.ExitCode == 0)`
`31`		`- .FailWith(AppendDiagnosticsTo($"Expected command to pass but it did not."));`
	`29`	`+ _commandResult.ExitCode.Should().Be(0, AppendDiagnosticsTo($"Expected command to pass but it did not."));`
`32`	`30`	`return new AndConstraint<CommandResultAssertions>(this);`
`33`	`31`	`}`
`34`	`32`
`35`	`33`	`internal AndConstraint<CommandResultAssertions> Fail()`
`36`	`34`	`{`
`37`		`- Execute.Assertion.ForCondition(_commandResult.ExitCode != 0)`
`38`		`- .FailWith(AppendDiagnosticsTo($"Expected command to fail but it did not."));`
	`35`	`+ _commandResult.ExitCode.Should().NotBe(0, AppendDiagnosticsTo($"Expected command to fail but it did not."));`
`39`	`36`	`return new AndConstraint<CommandResultAssertions>(this);`
`40`	`37`	`}`
`41`	`38`
`42`	`39`	`internal AndConstraint<CommandResultAssertions> HaveStdOut()`
`43`	`40`	`{`
`44`		`- Execute.Assertion.ForCondition(!string.IsNullOrEmpty(_commandResult.StdOut))`
`45`		`- .FailWith(AppendDiagnosticsTo("Command did not output anything to stdout"));`
	`41`	`+ _commandResult.StdOut.Should().NotBeNullOrEmpty(AppendDiagnosticsTo("Command did not output anything to stdout"));`
`46`	`42`	`return new AndConstraint<CommandResultAssertions>(this);`
`47`	`43`	`}`
`48`	`44`
`49`	`45`	`internal AndConstraint<CommandResultAssertions> HaveStdOut(string expectedOutput)`
`50`	`46`	`{`
`51`		`- Execute.Assertion.ForCondition(_commandResult.StdOut!.Equals(expectedOutput, StringComparison.Ordinal))`
`52`		`- .FailWith(AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));`
	`47`	`+ _commandResult.StdOut.Should().Be(expectedOutput, AppendDiagnosticsTo($"Command did not output with Expected Output. Expected: {expectedOutput}"));`
`53`	`48`	`return new AndConstraint<CommandResultAssertions>(this);`
`54`	`49`	`}`
`55`	`50`
`56`	`51`	`internal AndConstraint<CommandResultAssertions> HaveStdOutContaining(string pattern)`
`57`	`52`	`{`
`58`		`- Execute.Assertion.ForCondition(_commandResult.StdOut!.Contains(pattern))`
`59`		`- .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));`
	`53`	`+ _commandResult.StdOut.Should().Contain(pattern, AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));`
`60`	`54`	`return new AndConstraint<CommandResultAssertions>(this);`
`61`	`55`	`}`
`62`	`56`
`63`	`57`	`internal AndConstraint<CommandResultAssertions> HaveStdOutContaining(Func<string, bool> predicate, string description = "")`
`64`	`58`	`{`
`65`		`- Execute.Assertion.ForCondition(predicate(_commandResult.StdOut!))`
`66`		`- .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {description} {Environment.NewLine}"));`
	`59`	`+ predicate(_commandResult.StdOut!).Should().BeTrue(AppendDiagnosticsTo($"The command output did not contain expected result: {description} {Environment.NewLine}"));`
`67`	`60`	`return new AndConstraint<CommandResultAssertions>(this);`
`68`	`61`	`}`
`69`	`62`
`70`	`63`	`internal AndConstraint<CommandResultAssertions> NotHaveStdOutContaining(string pattern)`
`71`	`64`	`{`
`72`		`- Execute.Assertion.ForCondition(!_commandResult.StdOut!.Contains(pattern))`
`73`		`- .FailWith(AppendDiagnosticsTo($"The command output contained a result it should not have contained: {pattern}{Environment.NewLine}"));`
	`65`	`+ _commandResult.StdOut.Should().NotContain(pattern, AppendDiagnosticsTo($"The command output contained a result it should not have contained: {pattern}{Environment.NewLine}"));`
`74`	`66`	`return new AndConstraint<CommandResultAssertions>(this);`
`75`	`67`	`}`
`76`	`68`
`77`	`69`	`internal AndConstraint<CommandResultAssertions> NotHaveStdOutContainingIgnoreCase(string pattern)`
`78`	`70`	`{`
`79`		`- Execute.Assertion.ForCondition(!_commandResult.StdOut!.Contains(pattern, StringComparison.OrdinalIgnoreCase))`
`80`		`- .FailWith(AppendDiagnosticsTo($"The command output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));`
	`71`	`+ _commandResult.StdOut.Should().NotContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));`
`81`	`72`	`return new AndConstraint<CommandResultAssertions>(this);`
`82`	`73`	`}`
`83`	`74`
`84`	`75`	`internal AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreSpaces(string pattern)`
`85`	`76`	`{`
`86`		`- string commandResultNoSpaces = _commandResult.StdOut!.Replace(" ", "");`
`87`		`-`
`88`		`- Execute.Assertion`
`89`		`- .ForCondition(commandResultNoSpaces.Contains(pattern))`
`90`		`- .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));`
`91`		`-`
	`77`	`+ var commandResultNoSpaces = _commandResult.StdOut!.Replace(" ", "");`
	`78`	`+ commandResultNoSpaces.Should().Contain(pattern, AppendDiagnosticsTo($"The command output did not contain expected result: {pattern}{Environment.NewLine}"));`
`92`	`79`	`return new AndConstraint<CommandResultAssertions>(this);`
`93`	`80`	`}`
`94`	`81`
`95`	`82`	`internal AndConstraint<CommandResultAssertions> HaveStdOutContainingIgnoreCase(string pattern)`
`96`	`83`	`{`
`97`		`- Execute.Assertion.ForCondition(_commandResult.StdOut!.Contains(pattern, StringComparison.OrdinalIgnoreCase))`
`98`		`- .FailWith(AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));`
	`84`	`+ _commandResult.StdOut.Should().ContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command output did not contain expected result (ignoring case): {pattern}{Environment.NewLine}"));`
`99`	`85`	`return new AndConstraint<CommandResultAssertions>(this);`
`100`	`86`	`}`
`101`	`87`
`102`	`88`	`internal AndConstraint<CommandResultAssertions> HaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`103`	`89`	`{`
`104`		`- Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdOut!, pattern, options).Success)`
`105`		`- .FailWith(AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));`
	`90`	`+ _commandResult.StdOut.Should().MatchRegex(pattern, AppendDiagnosticsTo($"Matching the command output failed. Pattern: {pattern}{Environment.NewLine}"));`
`106`	`91`	`return new AndConstraint<CommandResultAssertions>(this);`
`107`	`92`	`}`
`108`	`93`
`109`	`94`	`internal AndConstraint<CommandResultAssertions> NotHaveStdOutMatching(string pattern, RegexOptions options = RegexOptions.None)`
`110`	`95`	`{`
`111`		`- Execute.Assertion.ForCondition(!Regex.Match(_commandResult.StdOut!, pattern, options).Success)`
`112`		`- .FailWith(AppendDiagnosticsTo($"The command output matched a pattern it should not have. Pattern: {pattern}{Environment.NewLine}"));`
	`96`	`+ _commandResult.StdOut.Should().NotMatchRegex(pattern, AppendDiagnosticsTo($"The command output matched a pattern it should not have contained: {pattern}{Environment.NewLine}"));`
`113`	`97`	`return new AndConstraint<CommandResultAssertions>(this);`
`114`	`98`	`}`
`115`	`99`
`116`	`100`	`internal AndConstraint<CommandResultAssertions> HaveStdErr()`
`117`	`101`	`{`
`118`		`- Execute.Assertion.ForCondition(!string.IsNullOrEmpty(_commandResult.StdErr))`
`119`		`- .FailWith(AppendDiagnosticsTo("Command did not output anything to stderr."));`
	`102`	`+ _commandResult.StdErr.Should().NotBeNullOrEmpty(AppendDiagnosticsTo("Command did not output anything to stderr."));`
`120`	`103`	`return new AndConstraint<CommandResultAssertions>(this);`
`121`	`104`	`}`
`122`	`105`
`123`	`106`	`internal AndConstraint<CommandResultAssertions> HaveStdErrContaining(string pattern)`
`124`	`107`	`{`
`125`		`- Execute.Assertion.ForCondition(_commandResult.StdErr!.Contains(pattern))`
`126`		`- .FailWith(AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));`
	`108`	`+ _commandResult.StdErr.Should().Contain(pattern, AppendDiagnosticsTo($"The command error output did not contain expected result: {pattern}{Environment.NewLine}"));`
`127`	`109`	`return new AndConstraint<CommandResultAssertions>(this);`
`128`	`110`	`}`
`129`	`111`
`130`	`112`	`internal AndConstraint<CommandResultAssertions> NotHaveStdErrContaining(string pattern)`
`131`	`113`	`{`
`132`		`- Execute.Assertion.ForCondition(!_commandResult.StdErr!.Contains(pattern))`
`133`		`- .FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));`
	`114`	`+ _commandResult.StdErr.Should().NotContain(pattern, AppendDiagnosticsTo($"The command error output contained a result it should not have contained: {pattern}{Environment.NewLine}"));`
`134`	`115`	`return new AndConstraint<CommandResultAssertions>(this);`
`135`	`116`	`}`
`136`	`117`
`137`	`118`	`internal AndConstraint<CommandResultAssertions> NotHaveStdErrContainingIgnoreCase(string pattern)`
`138`	`119`	`{`
`139`		`- Execute.Assertion.ForCondition(!_commandResult.StdErr!.Contains(pattern, StringComparison.OrdinalIgnoreCase))`
`140`		`- .FailWith(AppendDiagnosticsTo($"The command error output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));`
	`120`	`+ _commandResult.StdErr.Should().NotContainEquivalentOf(pattern, AppendDiagnosticsTo($"The command error output contained a result it should not have contained (ignoring case): {pattern}{Environment.NewLine}"));`
`141`	`121`	`return new AndConstraint<CommandResultAssertions>(this);`
`142`	`122`	`}`
`143`	`123`
`144`	`124`	`internal AndConstraint<CommandResultAssertions> HaveStdErrMatching(string pattern, RegexOptions options = RegexOptions.None)`
`145`	`125`	`{`
`146`		`- Execute.Assertion.ForCondition(Regex.Match(_commandResult.StdErr!, pattern, options).Success)`
`147`		`- .FailWith(AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));`
	`126`	`+ _commandResult.StdErr.Should().MatchRegex(pattern, AppendDiagnosticsTo($"Matching the command error output failed. Pattern: {pattern}{Environment.NewLine}"));`
`148`	`127`	`return new AndConstraint<CommandResultAssertions>(this);`
`149`	`128`	`}`
`150`	`129`
`151`	`130`	`internal AndConstraint<CommandResultAssertions> NotHaveStdOut()`
`152`	`131`	`{`
`153`		`- Execute.Assertion.ForCondition(string.IsNullOrEmpty(_commandResult.StdOut))`
`154`		`- .FailWith(AppendDiagnosticsTo($"Expected command to not output to stdout but it did:"));`
	`132`	`+ _commandResult.StdOut.Should().BeNullOrEmpty(AppendDiagnosticsTo($"Expected command to not output to stdout but it did:"));`
`155`	`133`	`return new AndConstraint<CommandResultAssertions>(this);`
`156`	`134`	`}`
`157`	`135`
`158`	`136`	`internal AndConstraint<CommandResultAssertions> NotHaveStdErr()`
`159`	`137`	`{`
`160`		`- Execute.Assertion.ForCondition(string.IsNullOrEmpty(_commandResult.StdErr))`
`161`		`- .FailWith(AppendDiagnosticsTo("Expected command to not output to stderr but it did:"));`
	`138`	`+ _commandResult.StdErr.Should().BeNullOrEmpty(AppendDiagnosticsTo("Expected command to not output to stderr but it did:"));`
`162`	`139`	`return new AndConstraint<CommandResultAssertions>(this);`
`163`	`140`	`}`
`164`	`141`