Avoid exceptions when wrapping in AssertionScope

Src/FluentAssertions/NumericAssertionsExtensions.cs

@@ -674,13 +674,16 @@ public static class NumericAssertionsExtensions
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue, precision);
 
-        var nonNullableAssertions = new SingleAssertions(parent.Subject.Value);
-        nonNullableAssertions.BeApproximately(expectedValue, precision, because, becauseArgs);
+        if (success)
+        {
+            var nonNullableAssertions = new SingleAssertions(parent.Subject.Value);
+            nonNullableAssertions.BeApproximately(expectedValue, precision, because, becauseArgs);
+        }
 
         return new AndConstraint<NullableNumericAssertions<float>>(parent);
     }
@@ -800,13 +803,16 @@ public static class NumericAssertionsExtensions
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue, precision);
 
-        var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value);
-        BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
+        if (success)
+        {
+            var nonNullableAssertions = new DoubleAssertions(parent.Subject.Value);
+            BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
+        }
 
         return new AndConstraint<NullableNumericAssertions<double>>(parent);
     }
@@ -926,13 +932,17 @@ public static class NumericAssertionsExtensions
     {
         Guard.ThrowIfArgumentIsNegative(precision);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(parent.Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context:value} to approximate {0} +/- {1}{reason}, but it was <null>.", expectedValue, precision);
 
-        var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value);
-        BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
+        if (success)
+        {
+            var nonNullableAssertions = new DecimalAssertions(parent.Subject.Value);
+            BeApproximately(nonNullableAssertions, expectedValue, precision, because, becauseArgs);
+        }
+
         return new AndConstraint<NullableNumericAssertions<decimal>>(parent);
     }
 

Src/FluentAssertions/Specialized/AsyncFunctionAssertions.cs

@@ -127,11 +127,16 @@ public AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extractor
     {
         Type expectedType = typeof(TException);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw exactly {0}{reason}, but found <null>.", expectedType);
 
+        if (!success)
+        {
+            return new ExceptionAssertions<TException>(Array.Empty<TException>());
+        }
+
         Exception exception = await InvokeWithInterceptionAsync(Subject);
 
         Execute.Assertion
@@ -158,11 +163,16 @@ public AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extractor
         params object[] becauseArgs)
         where TException : Exception
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw {0}{reason}, but found <null>.", typeof(TException));
 
+        if (!success)
+        {
+            return new ExceptionAssertions<TException>(Array.Empty<TException>());
+        }
+
         Exception exception = await InvokeWithInterceptionAsync(Subject);
         return ThrowInternal<TException>(exception, because, becauseArgs);
     }
@@ -179,11 +189,16 @@ public AsyncFunctionAssertions(Func<TTask> subject, IExtractExceptions extractor
     /// </param>
     public async Task<AndConstraint<TAssertions>> NotThrowAsync(string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
+        if (!success)
+        {
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         try
         {
             await Subject.Invoke();
@@ -209,11 +224,16 @@ public async Task<AndConstraint<TAssertions>> NotThrowAsync(string because = "",
     public async Task<AndConstraint<TAssertions>> NotThrowAsync<TException>(string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
+        if (!success)
+        {
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         try
         {
             await Subject.Invoke();
@@ -254,11 +274,16 @@ public Task<AndConstraint<TAssertions>> NotThrowAfterAsync(TimeSpan waitTime, Ti
         Guard.ThrowIfArgumentIsNegative(waitTime);
         Guard.ThrowIfArgumentIsNegative(pollInterval);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
+        if (!success)
+        {
+            return Task.FromResult(new AndConstraint<TAssertions>((TAssertions)this));
+        }
+
         return AssertionTaskAsync();
 
         async Task<AndConstraint<TAssertions>> AssertionTaskAsync()

Src/FluentAssertions/Specialized/DelegateAssertions.cs

@@ -38,11 +38,16 @@ private protected DelegateAssertions(TDelegate @delegate, IExtractExceptions ext
     public ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw {0}{reason}, but found <null>.", typeof(TException));
 
+        if (!success)
+        {
+            return new ExceptionAssertions<TException>(Array.Empty<TException>());
+        }
+
         FailIfSubjectIsAsyncVoid();
         Exception exception = InvokeSubjectWithInterception();
         return ThrowInternal<TException>(exception, because, becauseArgs);
@@ -61,11 +66,16 @@ public ExceptionAssertions<TException> Throw<TException>(string because = "", pa
     public AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
         where TException : Exception
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw {0}{reason}, but found <null>.", typeof(TException));
 
+        if (!success)
+        {
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         FailIfSubjectIsAsyncVoid();
         Exception exception = InvokeSubjectWithInterception();
         return NotThrowInternal<TException>(exception, because, becauseArgs);
@@ -83,11 +93,16 @@ public AndConstraint<TAssertions> NotThrow<TException>(string because = "", para
     /// </param>
     public AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
+        if (!success)
+        {
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         FailIfSubjectIsAsyncVoid();
         Exception exception = InvokeSubjectWithInterception();
         return NotThrowInternal(exception, because, becauseArgs);
@@ -113,11 +128,16 @@ public AndConstraint<TAssertions> NotThrow(string because = "", params object[]
         params object[] becauseArgs)
         where TException : Exception
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} to throw exactly {0}{reason}, but found <null>.", typeof(TException));
 
+        if (!success)
+        {
+            return new ExceptionAssertions<TException>(Array.Empty<TException>());
+        }
+
         FailIfSubjectIsAsyncVoid();
         Exception exception = InvokeSubjectWithInterception();
 
@@ -158,14 +178,20 @@ public AndConstraint<TAssertions> NotThrow(string because = "", params object[]
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="waitTime"/> or <paramref name="pollInterval"/> are negative.</exception>
     public AndConstraint<TAssertions> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval, string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        Guard.ThrowIfArgumentIsNegative(waitTime);
+        Guard.ThrowIfArgumentIsNegative(pollInterval);
+
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw after {0}{reason}, but found <null>.", waitTime);
 
+        if (!success)
+        {
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         FailIfSubjectIsAsyncVoid();
-        Guard.ThrowIfArgumentIsNegative(waitTime);
-        Guard.ThrowIfArgumentIsNegative(pollInterval);
 
         TimeSpan? invocationEndTime = null;
         Exception exception = null;

Src/FluentAssertions/Specialized/FunctionAssertions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.Security;
 using FluentAssertions.Common;
 using FluentAssertions.Execution;
 
@@ -40,12 +41,18 @@ protected override void InvokeSubject()
     /// </param>
     public new AndWhichConstraint<FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
            .ForCondition(Subject is not null)
            .BecauseOf(because, becauseArgs)
            .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
-        T result = FunctionAssertionHelpers.NotThrow(Subject, because, becauseArgs);
+        T result = default;
+
+        if (success)
+        {
+            result = FunctionAssertionHelpers.NotThrow(Subject, because, becauseArgs);
+        }
+
         return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result);
     }
 
@@ -74,12 +81,18 @@ protected override void InvokeSubject()
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="waitTime"/> or <paramref name="pollInterval"/> are negative.</exception>
     public new AndWhichConstraint<FunctionAssertions<T>, T> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval, string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
-        T result = FunctionAssertionHelpers.NotThrowAfter(Subject, Clock, waitTime, pollInterval, because, becauseArgs);
+        T result = default;
+
+        if (success)
+        {
+            result = FunctionAssertionHelpers.NotThrowAfter(Subject, Clock, waitTime, pollInterval, because, becauseArgs);
+        }
+
         return new AndWhichConstraint<FunctionAssertions<T>, T>(this, result);
     }
 }

Src/FluentAssertions/Specialized/GenericAsyncFunctionAssertions.cs

@@ -79,11 +79,16 @@ public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExcep
     public new async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>> NotThrowAsync(
         string because = "", params object[] becauseArgs)
     {
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw{reason}, but found <null>.");
 
+        if (!success)
+        {
+            return new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, default(TResult));
+        }
+
         try
         {
             TResult result = await Subject.Invoke();
@@ -125,11 +130,17 @@ public GenericAsyncFunctionAssertions(Func<Task<TResult>> subject, IExtractExcep
         Guard.ThrowIfArgumentIsNegative(waitTime);
         Guard.ThrowIfArgumentIsNegative(pollInterval);
 
-        Execute.Assertion
+        bool success = Execute.Assertion
             .ForCondition(Subject is not null)
             .BecauseOf(because, becauseArgs)
             .FailWith("Expected {context} not to throw any exceptions after {0}{reason}, but found <null>.", waitTime);
 
+        if (!success)
+        {
+            var result = new AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>(this, default(TResult));
+            return Task.FromResult(result);
+        }
+
         return AssertionTaskAsync();
 
         async Task<AndWhichConstraint<GenericAsyncFunctionAssertions<TResult>, TResult>> AssertionTaskAsync()