NET-1244 Write UTs for uncovered extension methods in IOperationExtension

Author: Tim-Pohlmann

analyzers/src/SonarAnalyzer.CFG/Extensions/IOperationExtensions.cs

@@ -142,15 +142,18 @@ public static IEnumerable<IOperation> DescendantsAndSelf(this IOperation operati
     public static IDeclarationPatternOperationWrapper? AsDeclarationPattern(this IOperation operation) =>
         operation.As(OperationKindEx.DeclarationPattern, IDeclarationPatternOperationWrapper.FromOperation);
 
-    public static IFlowCaptureOperationWrapper? AsFlowCapture(this IOperation operation) =>
-        operation.As(OperationKindEx.FlowCapture, IFlowCaptureOperationWrapper.FromOperation);
-
     public static IFlowCaptureReferenceOperationWrapper? AsFlowCaptureReference(this IOperation operation) =>
         operation.As(OperationKindEx.FlowCaptureReference, IFlowCaptureReferenceOperationWrapper.FromOperation);
 
-    // Other LoopKinds (e.g. For, While) are still OperationKindEx.Loop, but cannot be cast to IForEachLoopOperationWrapper so we need an additional check
-    public static IForEachLoopOperationWrapper? AsForEachLoop(this IOperation operation) =>
-        IForEachLoopOperationWrapper.IsInstance(operation) ? IForEachLoopOperationWrapper.FromOperation(operation) : null;
+    public static IForEachLoopOperationWrapper? AsForEachLoop(this IOperation operation)
+    {
+        if (operation is null)  // null check to be consistent with other the other As methods
+        {
+            throw new NullReferenceException(nameof(operation));
+        }
+        // Other LoopKinds (e.g. For, While) are still OperationKindEx.Loop, but cannot be cast to IForEachLoopOperationWrapper so we need an additional check
+        return IForEachLoopOperationWrapper.IsInstance(operation) ? IForEachLoopOperationWrapper.FromOperation(operation) : null;
+    }
 
     public static IInvocationOperationWrapper? AsInvocation(this IOperation operation) =>
         operation.As(OperationKindEx.Invocation, IInvocationOperationWrapper.FromOperation);
@@ -242,12 +245,6 @@ public static IFlowCaptureOperationWrapper ToFlowCapture(this IOperation operati
     public static IFlowCaptureReferenceOperationWrapper ToFlowCaptureReference(this IOperation operation) =>
         IFlowCaptureReferenceOperationWrapper.FromOperation(operation);
 
-    public static IForEachLoopOperationWrapper ToForEachLoop(this IOperation operation) =>
-        IForEachLoopOperationWrapper.FromOperation(operation);
-
-    public static ILoopOperationWrapper ToLoop(this IOperation operation) =>
-        ILoopOperationWrapper.FromOperation(operation);
-
     public static IIncrementOrDecrementOperationWrapper ToIncrementOrDecrement(this IOperation operation) =>
         IIncrementOrDecrementOperationWrapper.FromOperation(operation);
 

analyzers/tests/SonarAnalyzer.Core.Test/Extensions/IOperationExtensionsTest.cs

@@ -0,0 +1,105 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2014-2025 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the Sonar Source-Available License Version 1, as published by SonarSource SA.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace SonarAnalyzer.CFG.Extensions.Test;
+
+[TestClass]
+public class IOperationExtensionsTest
+{
+    [TestMethod]
+    public void DescendantsAndSelf_Null_ReturnsNull() =>
+        IOperationExtensions.DescendantsAndSelf(null).Should().BeEmpty();
+
+    [TestMethod]
+    public void OperationWrapperSonarPropertyShortcuts()
+    {
+        var operation = Operation<VariableDeclarationSyntax>("""
+            public class Sample
+            {
+                public void Method()
+                {
+                    var value = 42;
+                }
+            }
+            """).ToVariableDeclaration();
+        operation.Parent().Should().NotBeNull();
+        operation.Parent().Kind.Should().Be(OperationKind.VariableDeclarationGroup);
+        operation.Children().Should().HaveCount(1);
+        operation.Children().Single().Kind.Should().Be(OperationKind.VariableDeclarator);
+        operation.Language().Should().Be("C#");
+        operation.IsImplicit().Should().Be(false);
+        operation.SemanticModel().Should().Be(operation.SemanticModel());
+    }
+
+    [TestMethod]
+    public void AsForEachLoop_ForEachLoop_ConvertsToWrapper() =>
+        Operation<MethodDeclarationSyntax>("""
+            public class Sample
+            {
+                public void Method(int[] items)
+                {
+                    foreach (var item in items)
+                    {
+                        // Do something with item
+                    }
+                }
+            }
+            """).Descendants().OfType<ILoopOperation>().Single().AsForEachLoop().Should().NotBeNull();
+
+    [DataTestMethod]
+    [DataRow("for (var i = 0; i < 9; i++) { }")]
+    [DataRow("while (true) { }")]
+    [DataRow("do { } while (true);")]
+    public void AsForEachLoop_OtherLoop_ConvertsToWrapper(string loop) =>
+        Operation<MethodDeclarationSyntax>($$"""
+            public class Sample
+            {
+                public void Method()
+                {
+                    {{loop}}
+                }
+            }
+            """).Descendants().OfType<ILoopOperation>().Single().AsForEachLoop().Should().BeNull();
+
+    [TestMethod]
+    public void ExtensionsMethodsUsedByArchitecture()
+    {
+        IOperation operation = null;
+        // These extension methods are used by sonar-architecture. Do not remove them.
+        Assert.ThrowsException<NullReferenceException>(() => operation.AsForEachLoop());
+        Assert.ThrowsException<NullReferenceException>(() => operation.AsVariableDeclarator());
+        operation.ToArrayCreation();
+        operation.ToCatchClause();
+        operation.ToConversion();
+        operation.ToInvocation();
+        operation.ToIsType();
+        operation.ToLocalFunction();
+        operation.ToMemberReference();
+        operation.ToObjectCreation();
+        operation.ToPattern();
+        operation.ToVariableDeclaration();
+        operation.ToVariableDeclarator();
+    }
+
+    private static IOperation Operation<T>(string code) where T : SyntaxNode
+    {
+        var (tree, model) = TestCompiler.CompileCS(code);
+        return model.GetOperation(tree.Single<T>());
+    }
+}