Fix IDE0011 warning (#2171)

Zombach · web-flow · commit 0c9bef1c5a34 · 2024-07-03T15:33:24.000Z
Fix IDE0011 warnings and remove rule suppression.
diff --git a/test/Polly.Specs/Bulkhead/BulkheadSpecsBase.cs b/test/Polly.Specs/Bulkhead/BulkheadSpecsBase.cs
@@ -78,7 +78,9 @@ protected BulkheadSpecsBase(ITestOutputHelper testOutputHelper)
     public void Should_control_executions_per_specification(int maxParallelization, int maxQueuingActions, int totalActions, bool cancelQueuing, bool cancelExecuting, string scenario)
     {
         if (totalActions < 0)
+        {
             throw new ArgumentOutOfRangeException(nameof(totalActions));
+        }
 
         MaxParallelization = maxParallelization;
         MaxQueuingActions = maxQueuingActions;
diff --git a/test/Polly.Specs/CircuitBreaker/AdvancedCircuitBreakerAsyncSpecs.cs b/test/Polly.Specs/CircuitBreaker/AdvancedCircuitBreakerAsyncSpecs.cs
@@ -1602,9 +1602,15 @@ await breaker.ExecuteAsync(async () =>
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -1711,9 +1717,15 @@ await breaker.ExecuteAsync(async () =>
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -2030,7 +2042,10 @@ await breaker.Awaiting(x => x.RaiseExceptionAsync<DivideByZeroException>())
         // Graceful cleanup: allow executions time to end naturally; timeout if any deadlocks; expose any execution faults.  This validates the test ran as expected (and background delegates are complete) before we assert on outcomes.
         longRunningExecution.Wait(testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (longRunningExecution.IsFaulted)
+        {
             throw longRunningExecution!.Exception!;
+        }
+
         longRunningExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
         // onBreak() should still only have been called once.
diff --git a/test/Polly.Specs/CircuitBreaker/AdvancedCircuitBreakerSpecs.cs b/test/Polly.Specs/CircuitBreaker/AdvancedCircuitBreakerSpecs.cs
@@ -1605,9 +1605,15 @@ public void Should_only_allow_single_execution_on_first_entering_halfopen_state_
 #pragma warning restore xUnit1031 // Do not use blocking task operations in test method
 
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -1717,9 +1723,15 @@ public void Should_allow_single_execution_per_break_duration_in_halfopen_state__
 #pragma warning restore xUnit1031 // Do not use blocking task operations in test method
 
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
diff --git a/test/Polly.Specs/CircuitBreaker/CircuitBreakerAsyncSpecs.cs b/test/Polly.Specs/CircuitBreaker/CircuitBreakerAsyncSpecs.cs
@@ -454,9 +454,15 @@ await breaker.ExecuteAsync(async () =>
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -557,9 +563,15 @@ await breaker.ExecuteAsync(async () =>
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -822,7 +834,10 @@ await breaker.Awaiting(x => x.RaiseExceptionAsync<DivideByZeroException>())
         // Graceful cleanup: allow executions time to end naturally; timeout if any deadlocks; expose any execution faults.  This validates the test ran as expected (and background delegates are complete) before we assert on outcomes.
         longRunningExecution.Wait(testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (longRunningExecution.IsFaulted)
+        {
             throw longRunningExecution!.Exception!;
+        }
+
         longRunningExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
         // onBreak() should still only have been called once.
diff --git a/test/Polly.Specs/CircuitBreaker/CircuitBreakerSpecs.cs b/test/Polly.Specs/CircuitBreaker/CircuitBreakerSpecs.cs
@@ -450,9 +450,15 @@ public void Should_only_allow_single_execution_on_first_entering_halfopen_state_
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -551,9 +557,15 @@ public void Should_allow_single_execution_per_break_duration_in_halfopen_state__
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -813,7 +825,10 @@ public void Should_call_onbreak_when_breaking_circuit_first_time_but_not_for_sub
         // Graceful cleanup: allow executions time to end naturally; timeout if any deadlocks; expose any execution faults.  This validates the test ran as expected (and background delegates are complete) before we assert on outcomes.
         longRunningExecution.Wait(testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (longRunningExecution.IsFaulted)
+        {
             throw longRunningExecution!.Exception!;
+        }
+
         longRunningExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
         // onBreak() should still only have been called once.
diff --git a/test/Polly.Specs/CircuitBreaker/CircuitBreakerTResultAsyncSpecs.cs b/test/Polly.Specs/CircuitBreaker/CircuitBreakerTResultAsyncSpecs.cs
@@ -524,9 +524,15 @@ await breaker.ExecuteAsync(async () =>
 #pragma warning restore xUnit1031
 
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -635,9 +641,15 @@ await breaker.ExecuteAsync(async () =>
 #pragma warning restore xUnit1031
 
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -904,7 +916,10 @@ public async Task Should_call_onbreak_when_breaking_circuit_first_time_but_not_f
 #pragma warning restore xUnit1031
 
         if (longRunningExecution.IsFaulted)
+        {
             throw longRunningExecution!.Exception!;
+        }
+
         longRunningExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
         // onBreak() should still only have been called once.
diff --git a/test/Polly.Specs/CircuitBreaker/CircuitBreakerTResultSpecs.cs b/test/Polly.Specs/CircuitBreaker/CircuitBreakerTResultSpecs.cs
@@ -517,9 +517,15 @@ public void Should_only_allow_single_execution_on_first_entering_halfopen_state_
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -621,9 +627,15 @@ public void Should_allow_single_execution_per_break_duration_in_halfopen_state__
         permitFirstExecutionEnd.Set();
         Task.WaitAll(new[] { firstExecution, secondExecution }, testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (firstExecution.IsFaulted)
+        {
             throw firstExecution!.Exception!;
+        }
+
         if (secondExecution.IsFaulted)
+        {
             throw secondExecution!.Exception!;
+        }
+
         firstExecution.Status.Should().Be(TaskStatus.RanToCompletion);
         secondExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
@@ -885,7 +897,10 @@ public void Should_call_onbreak_when_breaking_circuit_first_time_but_not_for_sub
         // Graceful cleanup: allow executions time to end naturally; timeout if any deadlocks; expose any execution faults.  This validates the test ran as expected (and background delegates are complete) before we assert on outcomes.
         longRunningExecution.Wait(testTimeoutToExposeDeadlocks).Should().BeTrue();
         if (longRunningExecution.IsFaulted)
+        {
             throw longRunningExecution!.Exception!;
+        }
+
         longRunningExecution.Status.Should().Be(TaskStatus.RanToCompletion);
 
         // onBreak() should still only have been called once.
diff --git a/test/Polly.Specs/Helpers/Bulkhead/AssertionFailure.cs b/test/Polly.Specs/Helpers/Bulkhead/AssertionFailure.cs
@@ -5,7 +5,9 @@ public class AssertionFailure
     public AssertionFailure(int expected, int actual, string measure)
     {
         if (string.IsNullOrWhiteSpace(measure))
+        {
             throw new ArgumentNullException(nameof(measure));
+        }
 
         Expected = expected;
         Actual = actual;
diff --git a/test/Polly.Specs/Helpers/Caching/StubErroringCacheProvider.cs b/test/Polly.Specs/Helpers/Caching/StubErroringCacheProvider.cs
@@ -16,14 +16,20 @@ public StubErroringCacheProvider(Exception? getException, Exception? putExceptio
     public (bool, object?) TryGet(string key)
     {
         if (_getException != null)
+        {
             throw _getException;
+        }
+
         return _innerProvider.TryGet(key);
     }
 
     public void Put(string key, object? value, Ttl ttl)
     {
         if (_putException != null)
+        {
             throw _putException;
+        }
+
         _innerProvider.Put(key, value, ttl);
     }
 
diff --git a/test/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AddBehaviourIfHandleSyntax.cs b/test/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AddBehaviourIfHandleSyntax.cs
@@ -5,15 +5,19 @@ internal static class AddBehaviourIfHandleSyntax
     internal static AddBehaviourIfHandlePolicy WithBehaviour(this PolicyBuilder policyBuilder, Action<Exception> behaviourIfHandle)
     {
         if (behaviourIfHandle == null)
+        {
             throw new ArgumentNullException(nameof(behaviourIfHandle));
+        }
 
         return new AddBehaviourIfHandlePolicy(behaviourIfHandle, policyBuilder);
     }
 
     internal static AddBehaviourIfHandlePolicy<TResult> WithBehaviour<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>> behaviourIfHandle)
     {
         if (behaviourIfHandle == null)
+        {
             throw new ArgumentNullException(nameof(behaviourIfHandle));
+        }
 
         return new AddBehaviourIfHandlePolicy<TResult>(behaviourIfHandle, policyBuilder);
     }
diff --git a/test/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AsyncAddBehaviourIfHandleSyntax.cs b/test/Polly.Specs/Helpers/Custom/AddBehaviourIfHandle/AsyncAddBehaviourIfHandleSyntax.cs
@@ -7,7 +7,9 @@ internal static AsyncAddBehaviourIfHandlePolicy WithBehaviourAsync(
         Func<Exception, Task> behaviourIfHandle)
     {
         if (behaviourIfHandle == null)
+        {
             throw new ArgumentNullException(nameof(behaviourIfHandle));
+        }
 
         return new AsyncAddBehaviourIfHandlePolicy(behaviourIfHandle, policyBuilder);
     }
@@ -17,7 +19,9 @@ internal static AsyncAddBehaviourIfHandlePolicy<TResult> WithBehaviourAsync<TRes
         Func<DelegateResult<TResult>, Task> behaviourIfHandle)
     {
         if (behaviourIfHandle == null)
+        {
             throw new ArgumentNullException(nameof(behaviourIfHandle));
+        }
 
         return new AsyncAddBehaviourIfHandlePolicy<TResult>(behaviourIfHandle, policyBuilder);
     }
diff --git a/test/Polly.Specs/Polly.Specs.csproj b/test/Polly.Specs/Polly.Specs.csproj
@@ -9,7 +9,6 @@
     <Include>[Polly]*</Include>
     <IncludePollyUsings>true</IncludePollyUsings>
     <NoWarn>$(NoWarn);CA1030;CA1031;CA2008;CA2201</NoWarn>
-    <NoWarn>$(NoWarn);IDE0011</NoWarn>
     <NoWarn>$(NoWarn);S103;S104;S2184;S3878;S6966</NoWarn>
     <NoWarn>$(NoWarn);SA1204;SA1402;SA1600;SA1649</NoWarn>
   </PropertyGroup>
diff --git a/test/Polly.Specs/Retry/WaitAndRetryAsyncSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryAsyncSpecs.cs
@@ -647,12 +647,9 @@ public async Task Should_be_able_to_calculate_retry_timespans_based_on_the_handl
 
         using (var enumerator = expectedRetryWaits.GetEnumerator())
         {
-            await policy.ExecuteAsync(() =>
-            {
-                if (enumerator.MoveNext())
-                    throw enumerator.Current.Key;
-                return TaskHelper.EmptyTask;
-            });
+            await policy.ExecuteAsync(() => enumerator.MoveNext()
+                ? throw enumerator.Current.Key
+                : TaskHelper.EmptyTask);
         }
 
         actualRetryWaits.Should().ContainInOrder(expectedRetryWaits.Values);
diff --git a/test/Polly.Specs/Retry/WaitAndRetryForeverAsyncSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryForeverAsyncSpecs.cs
@@ -385,7 +385,10 @@ public async Task Should_be_able_to_calculate_retry_timespans_based_on_the_handl
             await policy.ExecuteAsync(() =>
             {
                 if (enumerator.MoveNext())
+                {
                     throw enumerator.Current.Key;
+                }
+
                 return TaskHelper.EmptyTask;
             });
         }
diff --git a/test/Polly.Specs/Retry/WaitAndRetryForeverSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryForeverSpecs.cs
@@ -309,7 +309,9 @@ public void Should_be_able_to_calculate_retry_timespans_based_on_the_handled_fau
             policy.Execute(() =>
             {
                 if (enumerator.MoveNext())
+                {
                     throw enumerator.Current.Key;
+                }
             });
         }
 
diff --git a/test/Polly.Specs/Retry/WaitAndRetryForeverTResultAsyncSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryForeverTResultAsyncSpecs.cs
@@ -32,10 +32,9 @@ public async Task Should_be_able_to_calculate_retry_timespans_based_on_the_handl
             await policy.ExecuteAsync(async () =>
             {
                 await TaskHelper.EmptyTask;
-                if (enumerator.MoveNext())
-                    return enumerator.Current.Key;
-                else
-                    return ResultPrimitive.Undefined;
+                return enumerator.MoveNext()
+                    ? enumerator.Current.Key
+                    : ResultPrimitive.Undefined;
             });
         }
 
diff --git a/test/Polly.Specs/Retry/WaitAndRetryForeverTResultSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryForeverTResultSpecs.cs
diff --git a/test/Polly.Specs/Retry/WaitAndRetrySpecs.cs b/test/Polly.Specs/Retry/WaitAndRetrySpecs.cs
diff --git a/test/Polly.Specs/Retry/WaitAndRetryTResultAsyncSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryTResultAsyncSpecs.cs
diff --git a/test/Polly.Specs/Retry/WaitAndRetryTResultSpecs.cs b/test/Polly.Specs/Retry/WaitAndRetryTResultSpecs.cs
diff --git a/test/Polly.Specs/Timeout/TimeoutSpecsBase.cs b/test/Polly.Specs/Timeout/TimeoutSpecsBase.cs

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,9 @@ protected BulkheadSpecsBase(ITestOutputHelper testOutputHelper)`
`78`	`78`	`public void Should_control_executions_per_specification(int maxParallelization, int maxQueuingActions, int totalActions, bool cancelQueuing, bool cancelExecuting, string scenario)`
`79`	`79`	`{`
`80`	`80`	`if (totalActions < 0)`
	`81`	`+ {`
`81`	`82`	`throw new ArgumentOutOfRangeException(nameof(totalActions));`
	`83`	`+ }`
`82`	`84`
`83`	`85`	`MaxParallelization = maxParallelization;`
`84`	`86`	`MaxQueuingActions = maxQueuingActions;`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,9 @@ public class AssertionFailure`
`5`	`5`	`public AssertionFailure(int expected, int actual, string measure)`
`6`	`6`	`{`
`7`	`7`	`if (string.IsNullOrWhiteSpace(measure))`
	`8`	`+ {`
`8`	`9`	`throw new ArgumentNullException(nameof(measure));`
	`10`	`+ }`
`9`	`11`
`10`	`12`	`Expected = expected;`
`11`	`13`	`Actual = actual;`
Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,20 @@ public StubErroringCacheProvider(Exception? getException, Exception? putExceptio`
`16`	`16`	`public (bool, object?) TryGet(string key)`
`17`	`17`	`{`
`18`	`18`	`if (_getException != null)`
	`19`	`+ {`
`19`	`20`	`throw _getException;`
	`21`	`+ }`
	`22`	`+`
`20`	`23`	`return _innerProvider.TryGet(key);`
`21`	`24`	`}`
`22`	`25`
`23`	`26`	`public void Put(string key, object? value, Ttl ttl)`
`24`	`27`	`{`
`25`	`28`	`if (_putException != null)`
	`29`	`+ {`
`26`	`30`	`throw _putException;`
	`31`	`+ }`
	`32`	`+`
`27`	`33`	`_innerProvider.Put(key, value, ttl);`
`28`	`34`	`}`
`29`	`35`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,19 @@ internal static class AddBehaviourIfHandleSyntax`
`5`	`5`	`internal static AddBehaviourIfHandlePolicy WithBehaviour(this PolicyBuilder policyBuilder, Action<Exception> behaviourIfHandle)`
`6`	`6`	`{`
`7`	`7`	`if (behaviourIfHandle == null)`
	`8`	`+ {`
`8`	`9`	`throw new ArgumentNullException(nameof(behaviourIfHandle));`
	`10`	`+ }`
`9`	`11`
`10`	`12`	`return new AddBehaviourIfHandlePolicy(behaviourIfHandle, policyBuilder);`
`11`	`13`	`}`
`12`	`14`
`13`	`15`	`internal static AddBehaviourIfHandlePolicy<TResult> WithBehaviour<TResult>(this PolicyBuilder<TResult> policyBuilder, Action<DelegateResult<TResult>> behaviourIfHandle)`
`14`	`16`	`{`
`15`	`17`	`if (behaviourIfHandle == null)`
	`18`	`+ {`
`16`	`19`	`throw new ArgumentNullException(nameof(behaviourIfHandle));`
	`20`	`+ }`
`17`	`21`
`18`	`22`	`return new AddBehaviourIfHandlePolicy<TResult>(behaviourIfHandle, policyBuilder);`
`19`	`23`	`}`