fluentassertions · jnyrup · Oct 9, 2023 · Oct 8, 2023 · Oct 8, 2023
diff --git a/Src/FluentAssertions/Specialized/ActionAssertions.cs b/Src/FluentAssertions/Specialized/ActionAssertions.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using FluentAssertions.Common;
+using FluentAssertions.Execution;
 
 namespace FluentAssertions.Specialized;
 
@@ -20,6 +21,97 @@ public ActionAssertions(Action subject, IExtractExceptions extractor, IClock clo
     {
     }
 
+    /// <summary>
+    /// Asserts that the current <see cref="Delegate" /> does not throw any exception.
+    /// </summary>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+    /// </param>
+    public AndConstraint<ActionAssertions> NotThrow(string because = "", params object[] becauseArgs)
+    {
+        bool success = Execute.Assertion
+            .ForCondition(Subject is not null)
+            .BecauseOf(because, becauseArgs)
+            .FailWith("Expected {context} not to throw{reason}, but found <null>.");
+
+        if (success)
+        {
+            FailIfSubjectIsAsyncVoid();
+            Exception exception = InvokeSubjectWithInterception();
+            return NotThrowInternal(exception, because, becauseArgs);
+        }
+
+        return new AndConstraint<ActionAssertions>(this);
+    }
+
+    /// <summary>
+    /// Asserts that the current <see cref="Delegate"/> stops throwing any exception
+    /// after a specified amount of time.
+    /// </summary>
+    /// <remarks>
+    /// The delegate is invoked. If it raises an exception,
+    /// the invocation is repeated until it either stops raising any exceptions
+    /// or the specified wait time is exceeded.
+    /// </remarks>
+    /// <param name="waitTime">
+    /// The time after which the delegate should have stopped throwing any exception.
+    /// </param>
+    /// <param name="pollInterval">
+    /// The time between subsequent invocations of the delegate.
+    /// </param>
+    /// <param name="because">
+    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+    /// </param>
+    /// <param name="becauseArgs">
+    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+    /// </param>
+    /// <exception cref="ArgumentOutOfRangeException"><paramref name="waitTime"/> or <paramref name="pollInterval"/> are negative.</exception>
+    public AndConstraint<ActionAssertions> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval, string because = "",
+        params object[] becauseArgs)
+    {
+        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)
+        {
+            FailIfSubjectIsAsyncVoid();
+
+            TimeSpan? invocationEndTime = null;
+            Exception exception = null;
+            ITimer timer = Clock.StartTimer();
+
+            while (invocationEndTime is null || invocationEndTime < waitTime)
+            {
+                exception = InvokeSubjectWithInterception();
+
+                if (exception is null)
+                {
+                    break;
+                }
+
+                Clock.Delay(pollInterval);
+                invocationEndTime = timer.Elapsed;
+            }
+
+            Execute.Assertion
+                .BecauseOf(because, becauseArgs)
+                .ForCondition(exception is null)
+                .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
+        }
+
+        return new AndConstraint<ActionAssertions>(this);
+    }
+
     protected override void InvokeSubject()
     {
         Subject();

diff --git a/Src/FluentAssertions/Specialized/DelegateAssertions.cs b/Src/FluentAssertions/Specialized/DelegateAssertions.cs
@@ -81,33 +81,6 @@ public AndConstraint<TAssertions> NotThrow<TException>(string because = "", para
         return new AndConstraint<TAssertions>((TAssertions)this);
     }
 
-    /// <summary>
-    /// Asserts that the current <see cref="Delegate" /> does not throw any exception.
-    /// </summary>
-    /// <param name="because">
-    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
-    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
-    /// </param>
-    /// <param name="becauseArgs">
-    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
-    /// </param>
-    public AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs)
-    {
-        bool success = Execute.Assertion
-            .ForCondition(Subject is not null)
-            .BecauseOf(because, becauseArgs)
-            .FailWith("Expected {context} not to throw{reason}, but found <null>.");
-
-        if (success)
-        {
-            FailIfSubjectIsAsyncVoid();
-            Exception exception = InvokeSubjectWithInterception();
-            return NotThrowInternal(exception, because, becauseArgs);
-        }
-
-        return new AndConstraint<TAssertions>((TAssertions)this);
-    }
-
     /// <summary>
     /// Asserts that the current <see cref="Delegate"/> throws an exception of the exact type <typeparamref name="TException"/> (and not a derived exception type).
     /// </summary>
@@ -153,73 +126,9 @@ public ExceptionAssertions<TException> ThrowExactly<TException>(string because =
         return new ExceptionAssertions<TException>(Array.Empty<TException>());
     }
 
-    /// <summary>
-    /// Asserts that the current <see cref="Delegate"/> stops throwing any exception
-    /// after a specified amount of time.
-    /// </summary>
-    /// <remarks>
-    /// The delegate is invoked. If it raises an exception,
-    /// the invocation is repeated until it either stops raising any exceptions
-    /// or the specified wait time is exceeded.
-    /// </remarks>
-    /// <param name="waitTime">
-    /// The time after which the delegate should have stopped throwing any exception.
-    /// </param>
-    /// <param name="pollInterval">
-    /// The time between subsequent invocations of the delegate.
-    /// </param>
-    /// <param name="because">
-    /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
-    /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
-    /// </param>
-    /// <param name="becauseArgs">
-    /// Zero or more objects to format using the placeholders in <paramref name="because" />.
-    /// </param>
-    /// <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)
-    {
-        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)
-        {
-            FailIfSubjectIsAsyncVoid();
-
-            TimeSpan? invocationEndTime = null;
-            Exception exception = null;
-            ITimer timer = Clock.StartTimer();
-
-            while (invocationEndTime is null || invocationEndTime < waitTime)
-            {
-                exception = InvokeSubjectWithInterception();
-
-                if (exception is null)
-                {
-                    break;
-                }
-
-                Clock.Delay(pollInterval);
-                invocationEndTime = timer.Elapsed;
-            }
-
-            Execute.Assertion
-                .BecauseOf(because, becauseArgs)
-                .ForCondition(exception is null)
-                .FailWith("Did not expect any exceptions after {0}{reason}, but found {1}.", waitTime, exception);
-        }
-
-        return new AndConstraint<TAssertions>((TAssertions)this);
-    }
-
     protected abstract void InvokeSubject();
 
-    private Exception InvokeSubjectWithInterception()
+    private protected Exception InvokeSubjectWithInterception()
     {
         Exception actualException = null;
 
@@ -248,7 +157,7 @@ private Exception InvokeSubjectWithInterception()
         return actualException;
     }
 
-    private void FailIfSubjectIsAsyncVoid()
+    private protected void FailIfSubjectIsAsyncVoid()
     {
         if (Subject.GetMethodInfo().IsDecoratedWithOrInherit<AsyncStateMachineAttribute>())
         {

diff --git a/Src/FluentAssertions/Specialized/FunctionAssertions.cs b/Src/FluentAssertions/Specialized/FunctionAssertions.cs
@@ -38,7 +38,7 @@ protected override void InvokeSubject()
     /// <param name="becauseArgs">
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
-    public new AndWhichConstraint<FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs)
+    public AndWhichConstraint<FunctionAssertions<T>, T> NotThrow(string because = "", params object[] becauseArgs)
     {
         bool success = Execute.Assertion
             .ForCondition(Subject is not null)
@@ -78,7 +78,7 @@ protected override void InvokeSubject()
     /// Zero or more objects to format using the placeholders in <paramref name="because" />.
     /// </param>
     /// <exception cref="ArgumentOutOfRangeException"><paramref name="waitTime"/> or <paramref name="pollInterval"/> are negative.</exception>
-    public new AndWhichConstraint<FunctionAssertions<T>, T> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval,
+    public AndWhichConstraint<FunctionAssertions<T>, T> NotThrowAfter(TimeSpan waitTime, TimeSpan pollInterval,
         string because = "", params object[] becauseArgs)
     {
         bool success = Execute.Assertion

diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt
@@ -2088,6 +2088,8 @@ namespace FluentAssertions.Specialized
         public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
     }
     public class AsyncFunctionAssertions<TTask, TAssertions> : FluentAssertions.Specialized.DelegateAssertionsBase<System.Func<TTask>, TAssertions>
         where TTask : System.Threading.Tasks.Task
@@ -2121,10 +2123,8 @@ namespace FluentAssertions.Specialized
     {
         protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
         protected abstract void InvokeSubject();
-        public FluentAssertions.AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
-        public FluentAssertions.AndConstraint<TAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> ThrowExactly<TException>(string because = "", params object[] becauseArgs)

diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt
@@ -2209,6 +2209,8 @@ namespace FluentAssertions.Specialized
         public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
     }
     public class AsyncFunctionAssertions<TTask, TAssertions> : FluentAssertions.Specialized.DelegateAssertionsBase<System.Func<TTask>, TAssertions>
         where TTask : System.Threading.Tasks.Task
@@ -2242,10 +2244,8 @@ namespace FluentAssertions.Specialized
     {
         protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
         protected abstract void InvokeSubject();
-        public FluentAssertions.AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
-        public FluentAssertions.AndConstraint<TAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> ThrowExactly<TException>(string because = "", params object[] becauseArgs)

diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.0.verified.txt
@@ -2039,6 +2039,8 @@ namespace FluentAssertions.Specialized
         public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
     }
     public class AsyncFunctionAssertions<TTask, TAssertions> : FluentAssertions.Specialized.DelegateAssertionsBase<System.Func<TTask>, TAssertions>
         where TTask : System.Threading.Tasks.Task
@@ -2072,10 +2074,8 @@ namespace FluentAssertions.Specialized
     {
         protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
         protected abstract void InvokeSubject();
-        public FluentAssertions.AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
-        public FluentAssertions.AndConstraint<TAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> ThrowExactly<TException>(string because = "", params object[] becauseArgs)

diff --git a/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt b/Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt
@@ -2088,6 +2088,8 @@ namespace FluentAssertions.Specialized
         public ActionAssertions(System.Action subject, FluentAssertions.Specialized.IExtractExceptions extractor, FluentAssertions.Common.IClock clock) { }
         protected override string Identifier { get; }
         protected override void InvokeSubject() { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
+        public FluentAssertions.AndConstraint<FluentAssertions.Specialized.ActionAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
     }
     public class AsyncFunctionAssertions<TTask, TAssertions> : FluentAssertions.Specialized.DelegateAssertionsBase<System.Func<TTask>, TAssertions>
         where TTask : System.Threading.Tasks.Task
@@ -2121,10 +2123,8 @@ namespace FluentAssertions.Specialized
     {
         protected DelegateAssertions(TDelegate @delegate, FluentAssertions.Specialized.IExtractExceptions extractor) { }
         protected abstract void InvokeSubject();
-        public FluentAssertions.AndConstraint<TAssertions> NotThrow(string because = "", params object[] becauseArgs) { }
         public FluentAssertions.AndConstraint<TAssertions> NotThrow<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
-        public FluentAssertions.AndConstraint<TAssertions> NotThrowAfter(System.TimeSpan waitTime, System.TimeSpan pollInterval, string because = "", params object[] becauseArgs) { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> Throw<TException>(string because = "", params object[] becauseArgs)
             where TException : System.Exception { }
         public FluentAssertions.Specialized.ExceptionAssertions<TException> ThrowExactly<TException>(string because = "", params object[] becauseArgs)

diff --git a/docs/_pages/releases.md b/docs/_pages/releases.md
@@ -48,6 +48,7 @@ sidebar:
   * Its constructor has been made `protected`.
   * Unused constructors have been removed.
   * Methods overwritten in `GenericAsyncFunctionAssertions` has been moved to `NonGenericAsyncFunctionAssertions`.
+* Moved the non-generic `NotThrow` and `NotThrowAfter` from `DelegateAssertions<TDelegate, TAssertions>` to `ActionAssertions` - [#2371](https://github.com/fluentassertions/fluentassertions/pull/2371)
 
 ## 6.12.0