add some more test coverage

Author: Bazeloth

src/ProgressOnderwijsUtils.Analyzers/IfNotFalseCodeFix.cs

@@ -6,6 +6,7 @@
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Formatting;
 
 namespace ProgressOnderwijsUtils.Analyzers;
 
@@ -51,15 +52,12 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         );
     }
 
-    private static SyntaxNode ReplaceWithBlockStatements(SyntaxNode root, IfStatementSyntax ifStatement, BlockSyntax block)
+    static SyntaxNode ReplaceWithBlockStatements(SyntaxNode root, IfStatementSyntax ifStatement, BlockSyntax block)
     {
-        var statements = block.Statements;
-        var firstStatement = statements[0]
-            .WithLeadingTrivia(ifStatement.GetLeadingTrivia())
-            .WithTrailingTrivia(block.GetTrailingTrivia());
+        var formattedStatements = block.Statements
+            .Select(s => s.WithAdditionalAnnotations(Formatter.Annotation))
+            .ToArray();
 
-        var newStatements = statements.Replace(statements[0], firstStatement);
-
-        return root.ReplaceNode(ifStatement, newStatements);
+        return root.ReplaceNode(ifStatement, formattedStatements);
     }
 }

test/ProgressOnderwijsUtils.Analyzers.Tests/IfNotFalseAnalyzerTest.cs

@@ -43,34 +43,125 @@ void M()
     [Fact]
     public async Task CodeFix_RemovesIfNotFalse()
     {
-        var source = """
-            class C
-            {
-                void M()
-                {
-                    if (!false) { System.Console.WriteLine("Hello"); }
-                }
-            }
-            """;
-        var expected = """
-            class C
-            {
-                void M()
-                {
-                    System.Console.WriteLine("Hello");
-                }
-            }
-            """;
+        var testCases = new[] {
+            new {
+                Source = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (!false) { System.Console.WriteLine("Hello"); }
+                        }
+                    }
+                    """,
+                Expected = """
+                    class C
+                    {
+                        void M()
+                        {
+                            System.Console.WriteLine("Hello");
+                        }
+                    }
+                    """,
+            },
+            new {
+                Source = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (!false) { System.Console.WriteLine("A"); System.Console.WriteLine("B"); }
+                        }
+                    }
+                    """,
+                Expected = """
+                    class C
+                    {
+                        void M()
+                        {
+                            System.Console.WriteLine("A"); System.Console.WriteLine("B");
+                        }
+                    }
+                    """,
+            },
+            new {
+                Source = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (!false)
+                            {
+                                System.Console.WriteLine("Hello");
+                            }
+                        }
+                    }
+                    """,
+                Expected = """
+                    class C
+                    {
+                        void M()
+                        {
+                            System.Console.WriteLine("Hello");
+                        }
+                    }
+                    """,
+            },
+            new {
+                Source = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (!false) { }
+                        }
+                    }
+                    """,
+                Expected = """
+                    class C
+                    {
+                        void M()
+                        {
+                        }
+                    }
+                    """,
+            },
+            new {
+                Source = """
+                    class C
+                    {
+                        void M()
+                        {
+                            if (!false)
+                            {
+                                System.Console.WriteLine("A");
+                                System.Console.WriteLine("B");
+                            }
+                        }
+                    }
+                    """,
+                Expected = """
+                    class C
+                    {
+                        void M()
+                        {
+                            System.Console.WriteLine("A");
+                            System.Console.WriteLine("B");
+                        }
+                    }
+                    """,
+            },
+        };
 
-        var workspace = DiagnosticHelper.CreateProjectWithTestFile(source);
-        var diagnostic = DiagnosticHelper.GetDiagnostics(new IfNotFalseAnalyzer(), workspace).Single();
+        foreach (var test in testCases) {
+            var workspace = DiagnosticHelper.CreateProjectWithTestFile(test.Source);
+            var diagnostic = DiagnosticHelper.GetDiagnostics(new IfNotFalseAnalyzer(), workspace).Single();
+            var fixesMade = await DiagnosticHelper.ApplyAllCodeFixes(workspace, diagnostic, new IfNotFalseCodeFix());
+            PAssert.That(() => fixesMade == 1);
 
-        var fixesMade = await DiagnosticHelper.ApplyAllCodeFixes(workspace, diagnostic, new IfNotFalseCodeFix());
-        PAssert.That(() => fixesMade == 1);
-        var result = await workspace.CurrentSolution.Projects.Single().Documents.Single().GetTextAsync();
-        Assert.Equal(
-            expected,
-            result.ToString()
-        );
+            var result = await workspace.CurrentSolution.Projects.Single().Documents.Single().GetTextAsync();
+            var resultText = result.ToString().Replace("\r\n", "\n");
+            Assert.Equal(test.Expected, resultText);
+        }
     }
 }