Detect using (Assert.EnterMultipleScope()) as an Assert.Multiple context.

Author: manfred-brands

src/nunit.analyzers.tests/Constants/NUnitFrameworkConstantsTests.cs

@@ -74,8 +74,10 @@ public sealed class NUnitFrameworkConstantsTests
             (nameof(NUnitFrameworkConstants.NameOfMultiple), nameof(Assert.Multiple)),
 #if NUNIT4
             (nameof(NUnitFrameworkConstants.NameOfMultipleAsync), nameof(Assert.MultipleAsync)),
+            (nameof(NUnitFrameworkConstants.NameOfEnterMultipleScope), nameof(Assert.EnterMultipleScope)),
 #else
             (nameof(NUnitFrameworkConstants.NameOfMultipleAsync), "MultipleAsync"),
+            (nameof(NUnitFrameworkConstants.NameOfEnterMultipleScope), "EnterMultipleScope"),
 #endif
 
             (nameof(NUnitFrameworkConstants.NameOfOut), nameof(TestContext.Out)),

src/nunit.analyzers.tests/UseAssertMultiple/UseAssertMultipleAnalyzerTests.cs

@@ -45,6 +45,38 @@ await Assert.MultipleAsync(async () =>
         }");
             RoslynAssert.Valid(this.analyzer, testCode);
         }
+
+#if WOULD_SOMEONE_ACTUALLY_USE_THIS
+        [Test]
+        public void AnalyzeWhenMultipleScopeDeclarationIsUsed()
+        {
+            var testCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@"
+        public void Test()
+        {
+            using IDisposable disposable = Assert.EnterMultipleScope();
+
+            Assert.That(true, Is.True);
+            disposable.Dispose();
+            Assert.That(false, Is.False);
+        }");
+            RoslynAssert.Valid(this.analyzer, testCode);
+        }
+#endif
+
+        [Test]
+        public void AnalyzeWhenMultipleScopeStatementIsUsed()
+        {
+            var testCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@"
+        public void Test()
+        {
+            using (Assert.EnterMultipleScope())
+            {
+                Assert.That(true, Is.True);
+                Assert.That(false, Is.False);
+            }
+        }");
+            RoslynAssert.Valid(this.analyzer, testCode);
+        }
 #endif
 
         [Test]

src/nunit.analyzers/Constants/NUnitFrameworkConstants.cs

@@ -53,6 +53,7 @@ public static class NUnitFrameworkConstants
 
         public const string NameOfMultiple = "Multiple";
         public const string NameOfMultipleAsync = "MultipleAsync";
+        public const string NameOfEnterMultipleScope = "EnterMultipleScope";
 
         public const string NameOfOut = "Out";
         public const string NameOfWrite = "Write";

src/nunit.analyzers/Helpers/AssertHelper.cs

@@ -95,18 +95,35 @@ public static bool IsLiteralOperation(IOperation operation)
         /// </summary>
         public static bool IsInsideAssertMultiple(SyntaxNode node)
         {
-            InvocationExpressionSyntax? possibleAssertMultiple;
-
-            while ((possibleAssertMultiple = node.Ancestors().OfType<InvocationExpressionSyntax>().FirstOrDefault()) is not null)
+            // Look for Assert.Multiple(delegate) invocation.
+            SyntaxNode currentNode = node;
+            InvocationExpressionSyntax? possibleAssertMultipleInvocation;
+            while ((possibleAssertMultipleInvocation = currentNode.Ancestors().OfType<InvocationExpressionSyntax>().FirstOrDefault()) is not null)
             {
                 // Is the statement inside a Block which is part of an Assert.Multiple.
-                if (IsAssert(possibleAssertMultiple, NUnitFrameworkConstants.NameOfMultiple, NUnitFrameworkConstants.NameOfMultipleAsync))
+                if (IsAssert(possibleAssertMultipleInvocation, NUnitFrameworkConstants.NameOfMultiple, NUnitFrameworkConstants.NameOfMultipleAsync))
+                {
+                    return true;
+                }
+
+                // Keep looking at possible parent nested expression.
+                currentNode = possibleAssertMultipleInvocation;
+            }
+
+            // Look for using (Assert.EnterMultipleScope()) invocation.
+            currentNode = node;
+            UsingStatementSyntax? usingStatement;
+            while ((usingStatement = currentNode.Ancestors().OfType<UsingStatementSyntax>().FirstOrDefault()) is not null)
+            {
+                // Is the using expression an Assert.EnterMultipleScope.
+                if (usingStatement.Expression is InvocationExpressionSyntax usingInvocation &&
+                    IsAssert(usingInvocation, NUnitFrameworkConstants.NameOfEnterMultipleScope))
                 {
                     return true;
                 }
 
                 // Keep looking at possible parent nested expression.
-                node = possibleAssertMultiple;
+                currentNode = usingStatement;
             }
 
             return false;