From 219376491bd201b8229b0206aed35442d7d11ab1 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Fri, 20 Jun 2025 16:39:52 +1000
Subject: [PATCH 1/6] Move formatting tests into their own folder, for better
 organization

---
 .../Formatting_NetFx/DocumentFormattingTest.cs                | 2 +-
 .../Formatting_NetFx/OnTypeFormattingTest.cs                  | 2 +-
 .../Cohost/{ => Formatting}/FormattingTestBase.cs             | 2 +-
 .../Cohost/{ => Formatting}/HtmlFormattingCollection.cs       | 0
 .../Microsoft.VisualStudio.LanguageServices.Razor.Test.csproj | 4 ++--
 5 files changed, 5 insertions(+), 5 deletions(-)
 rename src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/{ => Formatting}/FormattingTestBase.cs (99%)
 rename src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/{ => Formatting}/HtmlFormattingCollection.cs (100%)

diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
index 2a72f25a2bf..c855f721669 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
@@ -11,7 +11,7 @@
 using Xunit.Abstractions;
 
 #if COHOSTING
-namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
 #else
 namespace Microsoft.AspNetCore.Razor.LanguageServer.Formatting;
 #endif
diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/OnTypeFormattingTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/OnTypeFormattingTest.cs
index 5580eafd50f..dcd304f0bae 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/OnTypeFormattingTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/OnTypeFormattingTest.cs
@@ -9,7 +9,7 @@
 using Xunit.Abstractions;
 
 #if COHOSTING
-namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
 #else
 namespace Microsoft.AspNetCore.Razor.LanguageServer.Formatting;
 #endif
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/FormattingTestBase.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/FormattingTestBase.cs
similarity index 99%
rename from src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/FormattingTestBase.cs
rename to src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/FormattingTestBase.cs
index ab0ce45340c..35a4dd9b7f9 100644
--- a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/FormattingTestBase.cs
+++ b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/FormattingTestBase.cs
@@ -20,7 +20,7 @@
 using Xunit;
 using Xunit.Abstractions;
 
-namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
 
 public abstract class FormattingTestBase : CohostEndpointTestBase
 {
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HtmlFormattingCollection.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/HtmlFormattingCollection.cs
similarity index 100%
rename from src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/HtmlFormattingCollection.cs
rename to src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/HtmlFormattingCollection.cs
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Microsoft.VisualStudio.LanguageServices.Razor.Test.csproj b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Microsoft.VisualStudio.LanguageServices.Razor.Test.csproj
index f1888706c06..3f0816dd3e4 100644
--- a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Microsoft.VisualStudio.LanguageServices.Razor.Test.csproj
+++ b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Microsoft.VisualStudio.LanguageServices.Razor.Test.csproj
@@ -33,8 +33,8 @@
 
   <ItemGroup>
     <Compile Include="..\..\src\Microsoft.CodeAnalysis.Razor.Workspaces\GlobalUsings.cs" Link="GlobalUsings.cs" />
-    <Compile Include="..\Microsoft.AspNetCore.Razor.LanguageServer.Test\Formatting_NetFx\DocumentFormattingTest.cs" Link="Cohost\DocumentFormattingTest.cs" />
-    <Compile Include="..\Microsoft.AspNetCore.Razor.LanguageServer.Test\Formatting_NetFx\OnTypeFormattingTest.cs" Link="Cohost\OnTypeFormattingTest.cs" />
+    <Compile Include="..\Microsoft.AspNetCore.Razor.LanguageServer.Test\Formatting_NetFx\DocumentFormattingTest.cs" Link="Cohost\Formatting\DocumentFormattingTest.cs" />
+    <Compile Include="..\Microsoft.AspNetCore.Razor.LanguageServer.Test\Formatting_NetFx\OnTypeFormattingTest.cs" Link="Cohost\Formatting\OnTypeFormattingTest.cs" />
     <Compile Include="..\Microsoft.AspNetCore.Razor.LanguageServer.Test\XunitAssemblyInfo.cs" Link="XunitAssemblyInfo.cs" />
   </ItemGroup>
 

From 6692ae468c7d0d6b51e7a173e9bdeb3b65837567 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 23 Jun 2025 13:13:21 +1000
Subject: [PATCH 2/6] Fix logging in tests

---
 .../Cohost/CohostEndpointTestBase.cs                          | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostEndpointTestBase.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostEndpointTestBase.cs
index 360a00afb0d..122c69d6e28 100644
--- a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostEndpointTestBase.cs
+++ b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostEndpointTestBase.cs
@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.Razor.Remote;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.CodeAnalysis.Remote.Razor;
+using Microsoft.CodeAnalysis.Remote.Razor.Logging;
 using Microsoft.CodeAnalysis.Remote.Razor.SemanticTokens;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.NET.Sdk.Razor.SourceGenerators;
@@ -69,6 +70,9 @@ protected override async Task InitializeAsync()
 
         AddDisposable(_exportProvider);
 
+        var remoteLogger = _exportProvider.GetExportedValue<RemoteLoggerFactory>();
+        remoteLogger.SetTargetLoggerFactory(LoggerFactory);
+
         _remoteServiceInvoker = new TestRemoteServiceInvoker(JoinableTaskContext, _exportProvider, LoggerFactory);
         AddDisposable(_remoteServiceInvoker);
 

From 54be8f6e202bd74566e8b71302443627ac56aceb Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 23 Jun 2025 13:29:13 +1000
Subject: [PATCH 3/6] Add some failing (and one not-failing) tests

---
 .../DocumentFormattingTest.cs                 | 168 +++++++++++++++++-
 1 file changed, 165 insertions(+), 3 deletions(-)

diff --git a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
index c855f721669..34f64b6fa80 100644
--- a/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
+++ b/src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Formatting_NetFx/DocumentFormattingTest.cs
@@ -72,6 +72,168 @@ public void Bar() {
             });
     }
 
+    [FormattingTestFact]
+    public async Task RoslynFormatBracesAsKandR_CodeBlockBraceOnNextLine()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                <h1>count is @counter</h1>
+
+                @code
+                {
+                private int counter;
+
+                class Goo
+                {
+                    public void Bar()
+                    {
+                        counter++;
+                    }
+                }
+                }
+                """,
+            expected: """
+                <h1>count is @counter</h1>
+
+                @code
+                {
+                    private int counter;
+
+                    class Goo {
+                        public void Bar() {
+                            counter++;
+                        }
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.None
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task RoslynFormatBracesAsKandR_NoRazorOrHtml()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeOpenBraceInMethods
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task RoslynFormatBracesAsKandR_CodeBlockBraceOnNextLine_NoRazorOrHtml()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeOpenBraceInMethods
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task RoslynFormatBracesAsKandR_CodeBlockBraceIndented_NoRazorOrHtml()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                    {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeOpenBraceInMethods
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task RoslynFormatBracesAsKandR_CodeBlockBraceIndented_InsideHtml()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                <div>
+                @code
+                            {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                </div>
+                """,
+            expected: """
+                <div>
+                    @code
+                    {
+                        private bool IconMenuActive { get; set; } = false;
+                        protected void ToggleIconMenu(bool iconMenuActive)
+                        {
+                            IconMenuActive = iconMenuActive;
+                        }
+                    }
+                </div>
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeOpenBraceInMethods
+            });
+    }
+
     [FormattingTestFact]
     public async Task PropertyShrunkToOneLine()
     {
@@ -6422,8 +6584,8 @@ public Task NestedExplicitExpression3()
     [FormattingTestFact]
     [WorkItem("https://github.com/dotnet/razor/issues/11873")]
     public Task NestedExplicitExpression4()
-    => RunFormattingTestAsync(
-        input: """
+        => RunFormattingTestAsync(
+            input: """
                 @if (true)
                 {
                     <span>
@@ -6442,7 +6604,7 @@ public Task NestedExplicitExpression4()
                     </span>
                 }
                 """,
-        expected: """
+            expected: """
                 @if (true)
                 {
                     <span>

From cbce0b2ab9234771d4e1dfd6c607792399576db9 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 23 Jun 2025 15:56:16 +1000
Subject: [PATCH 4/6] Fix code block brace formatting when Roslyn moves the
 brace up a line

---
 .../Extensions/RazorSyntaxNodeExtensions.cs   | 12 +++----
 ...pFormattingPass.CSharpDocumentGenerator.cs | 36 +++++++------------
 .../Passes/New/CSharpFormattingPass.cs        | 19 +++++++++-
 3 files changed, 34 insertions(+), 33 deletions(-)

diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
index 6a1c2fee750..a259432fed9 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs
@@ -85,31 +85,27 @@ internal static bool IsAttributeDirective(this SyntaxNode node, [NotNullWhen(tru
         return false;
     }
 
-    internal static bool IsCodeDirective(this SyntaxNode node, out SyntaxToken openBraceToken)
+    internal static bool IsCodeDirective(this SyntaxNode node)
     {
         if (IsDirective(node, ComponentCodeDirective.Directive, out var body) &&
             body.CSharpCode is { Children: { Count: > 0 } children } &&
-            children.TryGetOpenBraceToken(out var openBrace))
+            children.TryGetOpenBraceToken(out _))
         {
-            openBraceToken = openBrace;
             return true;
         }
 
-        openBraceToken = default;
         return false;
     }
 
-    internal static bool IsFunctionsDirective(this SyntaxNode node, out SyntaxToken openBraceToken)
+    internal static bool IsFunctionsDirective(this SyntaxNode node)
     {
         if (IsDirective(node, FunctionsDirective.Directive, out var body) &&
             body.CSharpCode is { Children: { Count: > 0 } children } &&
-            children.TryGetOpenBraceToken(out var openBrace))
+            children.TryGetOpenBraceToken(out _))
         {
-            openBraceToken = openBrace;
             return true;
         }
 
-        openBraceToken = default;
         return false;
     }
 
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.CSharpDocumentGenerator.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.CSharpDocumentGenerator.cs
index 93b1fae7750..41bd342ed94 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.CSharpDocumentGenerator.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.CSharpDocumentGenerator.cs
@@ -695,14 +695,10 @@ public override LineInfo VisitRazorDirective(RazorDirectiveSyntax node)
                     return VisitTypeParamDirective(typeParam, conditions);
                 }
 
-                if (node.IsCodeDirective(out var openBrace))
+                if (node.IsCodeDirective() ||
+                    node.IsFunctionsDirective())
                 {
-                    return VisitCodeOrFunctionsDirective(openBrace);
-                }
-
-                if (node.IsFunctionsDirective(out var functionsOpenBrace))
-                {
-                    return VisitCodeOrFunctionsDirective(functionsOpenBrace);
+                    return VisitCodeOrFunctionsDirective();
                 }
 
                 // All other directives that have braces are handled here
@@ -721,25 +717,17 @@ body.CSharpCode is CSharpCodeBlockSyntax code &&
                 return EmitCurrentLineAsComment();
             }
 
-            private LineInfo VisitCodeOrFunctionsDirective(RazorSyntaxToken openBrace)
+            private LineInfo VisitCodeOrFunctionsDirective()
             {
-                // If the open brace is on the same line as the directive, then we need to ensure the contents are indented
-                if (GetLineNumber(openBrace) == GetLineNumber(_currentToken))
-                {
-                    // If its an @code or @functions we want to wrap the contents in a class
-                    // so that access modifiers are valid, and will be formatted as appropriate.
-                    _builder.AppendLine("class F");
-                    _builder.AppendLine("{");
-
-                    // Roslyn might move our brace to the previous line, so we might _not_ need to skip it 🤦‍
-                    return CreateLineInfo(skipNextLineIfBrace: true);
-                }
+                // If its an @code or @functions we want to wrap the contents in a class so that access modifiers
+                // on any members declared within it are valid, and will be formatted as appropriate.
+                // We let the users content be the class name, as it will either be "@code" or "@functions", which
+                // are both valid, and it might have an open brace after it, or that might be on the next line,
+                // but if we just let that flow to the generated document, we don't need to do any fancy checking.
+                _builder.Append("class ");
+                _builder.AppendLine(_currentLine.ToString());
 
-                // If the braces are on different lines, then we can do nothing, unless its an @code or @functions
-                // in which case we need to use a class. Note we don't output an open brace, as the next line of
-                // the original file will have one.
-                _builder.AppendLine("class F");
-                return CreateLineInfo();
+                return CreateLineInfo(skipNextLineIfBrace: true);
             }
 
             private LineInfo VisitUsingDirective()
diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.cs
index 74ae444cdb7..77bde625244 100644
--- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.cs
+++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/New/CSharpFormattingPass.cs
@@ -58,6 +58,11 @@ public async Task<ImmutableArray<TextChange>> ExecuteAsync(FormattingContext con
                 iFormatted++;
             }
 
+            if (iFormatted >= formattedCSharpText.Lines.Count)
+            {
+                break;
+            }
+
             var formattedLine = formattedCSharpText.Lines[iFormatted];
             if (lineInfo.ProcessIndentation &&
                 formattedLine.GetFirstNonWhitespaceOffset() is { } formattedIndentation)
@@ -139,7 +144,7 @@ public async Task<ImmutableArray<TextChange>> ExecuteAsync(FormattingContext con
             }
             else if (lineInfo.SkipNextLineIfBrace)
             {
-                // If the next line is a brace, we skip it, otherwise we don't. This is used to skip the opening brace of a class
+                // If the next line is a brace, we skip it. This is used to skip the opening brace of a class
                 // that we insert, but Roslyn settings might place on the same like as the class declaration.
                 if (iFormatted + 1 < formattedCSharpText.Lines.Count &&
                     formattedCSharpText.Lines[iFormatted + 1] is { Span.Length: > 0 } nextLine &&
@@ -147,6 +152,18 @@ public async Task<ImmutableArray<TextChange>> ExecuteAsync(FormattingContext con
                 {
                     iFormatted++;
                 }
+
+                // On the other hand, we might insert the opening brace of a class, and Roslyn might collapse
+                // it up to the previous line, so we would want to skip the next line in the original document
+                // in that case. Fortunately its illegal to have `@code {\r\n {` in a Razor file, so there can't
+                // be false positives here.
+                if (iOriginal + 1 < changedText.Lines.Count &&
+                    changedText.Lines[iOriginal + 1] is { } nextOriginalLine &&
+                    nextOriginalLine.GetFirstNonWhitespaceOffset() is { } firstChar &&
+                    nextOriginalLine.CharAt(firstChar) == '{')
+                {
+                    iOriginal++;
+                }
             }
         }
 

From 8b82e0a1d8e926f0ff1ba91fe468d16f70f8f7ff Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 23 Jun 2025 16:18:45 +1000
Subject: [PATCH 5/6] Add 120 auto-generated tests to cover the CSharp
 formatting newline options exhaustively-ish

---
 .../CSharpSyntaxFormattingOptionsTest.cs      | 1933 +++++++++++++++++
 ...rpSyntaxFormattingOptionsTest_Generator.cs |  129 ++
 .../ManualRunOnlyFactAttribute.cs             |   19 +
 3 files changed, 2081 insertions(+)
 create mode 100644 src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest.cs
 create mode 100644 src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest_Generator.cs
 create mode 100644 src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs

diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest.cs
new file mode 100644
index 00000000000..0b2c151bafe
--- /dev/null
+++ b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest.cs
@@ -0,0 +1,1933 @@
+// <auto-generated />
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Test.Common;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+using Microsoft.CodeAnalysis.Razor.Formatting;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
+
+[Collection(HtmlFormattingCollection.Name)]
+public class CSharpSyntaxFormattingOptionsTest(FormattingTestContext context, HtmlFormattingFixture fixture, ITestOutputHelper testOutput)
+    : FormattingTestBase(context, fixture.Service, testOutput), IClassFixture<FormattingTestContext>
+{
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInObjectInitializers_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInObjectInitializers_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInObjectInitializers_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInObjectInitializers_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInAnonymousTypes_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInAnonymousTypes_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInAnonymousTypes_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeMembersInAnonymousTypes_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeElse_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeElse_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeElse_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeElse_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeCatch_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeCatch_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeCatch_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeCatch_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeFinally_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeFinally_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeFinally_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeFinally_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInTypes_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInTypes_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInTypes_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInTypes_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousTypes_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousTypes_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousTypes_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousTypes_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInObjectCollectionArrayInitializers_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInObjectCollectionArrayInitializers_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInObjectCollectionArrayInitializers_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInObjectCollectionArrayInitializers_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInProperties_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInProperties_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInProperties_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInProperties_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInMethods_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive) {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInMethods_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive) {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInMethods_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive) {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInMethods_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive) {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAccessors_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAccessors_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAccessors_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAccessors_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousMethods_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousMethods_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousMethods_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInAnonymousMethods_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInLambdaExpressionBody_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInLambdaExpressionBody_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInLambdaExpressionBody_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInLambdaExpressionBody_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInControlBlocks_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInControlBlocks_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInControlBlocks_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBeforeOpenBraceInControlBlocks_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BetweenQueryExpressionClauses,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBetweenQueryExpressionClauses_SingleLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBetweenQueryExpressionClauses_SingleLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks,
+                WrappingKeepStatementsOnSingleLine = true,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBetweenQueryExpressionClauses_MultiLine_PreserveSingle()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = true,
+            });
+    }
+
+    [FormattingTestFact]
+    public async Task CSharpSyntaxFormattingOptions_WithoutBetweenQueryExpressionClauses_MultiLine_DontPreserve()
+    {
+        await RunFormattingTestAsync(
+            input: """
+                @code
+                {
+                private bool IconMenuActive { get; set; } = false;
+                protected void ToggleIconMenu(bool iconMenuActive)
+                {
+                IconMenuActive = iconMenuActive;
+                }
+                }
+                """,
+            expected: """
+                @code
+                {
+                    private bool IconMenuActive { get; set; } = false;
+                    protected void ToggleIconMenu(bool iconMenuActive)
+                    {
+                        IconMenuActive = iconMenuActive;
+                    }
+                }
+                """,
+            formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+            {
+                NewLines = RazorNewLinePlacement.BeforeMembersInObjectInitializers | RazorNewLinePlacement.BeforeMembersInAnonymousTypes | RazorNewLinePlacement.BeforeElse | RazorNewLinePlacement.BeforeCatch | RazorNewLinePlacement.BeforeFinally | RazorNewLinePlacement.BeforeOpenBraceInTypes | RazorNewLinePlacement.BeforeOpenBraceInAnonymousTypes | RazorNewLinePlacement.BeforeOpenBraceInObjectCollectionArrayInitializers | RazorNewLinePlacement.BeforeOpenBraceInProperties | RazorNewLinePlacement.BeforeOpenBraceInMethods | RazorNewLinePlacement.BeforeOpenBraceInAccessors | RazorNewLinePlacement.BeforeOpenBraceInAnonymousMethods | RazorNewLinePlacement.BeforeOpenBraceInLambdaExpressionBody | RazorNewLinePlacement.BeforeOpenBraceInControlBlocks,
+                WrappingKeepStatementsOnSingleLine = false,
+                WrappingPreserveSingleLine = false,
+            });
+    }
+}
diff --git a/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest_Generator.cs b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest_Generator.cs
new file mode 100644
index 00000000000..f3aa04c25f1
--- /dev/null
+++ b/src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/Formatting/CSharpSyntaxFormattingOptionsTest_Generator.cs
@@ -0,0 +1,129 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Test.Common;
+using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+
+namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
+
+public class CSharpSyntaxFormattingOptionsTest_Generator
+{
+    /// <summary>
+    /// This test can be run manually to generate exhaustive tests for RazorCSharpSyntaxFormattingOptions.
+    /// </summary>
+    /// <remarks>
+    /// After running this test, the file will be updated but you should expect the "expected" output to be incorrect
+    /// and you'll have to manually adjust it, which is why regenerating the tests is a manual process.
+    /// Or make the test generation much smarter I guess :)
+    /// </remarks>
+    [ManualRunOnlyFact]
+    public void GenerateTests()
+    {
+        //lang=C#-test
+        var fileHeader = """
+            // <auto-generated />
+            
+            using System;
+            using System.Threading.Tasks;
+            using Microsoft.AspNetCore.Razor.Language;
+            using Microsoft.AspNetCore.Razor.Test.Common;
+            using Microsoft.CodeAnalysis.ExternalAccess.Razor.Features;
+            using Microsoft.CodeAnalysis.Razor.Formatting;
+            using Xunit;
+            using Xunit.Abstractions;
+
+            namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost.Formatting;
+
+            [Collection(HtmlFormattingCollection.Name)]
+            public class CSharpSyntaxFormattingOptionsTest(FormattingTestContext context, HtmlFormattingFixture fixture, ITestOutputHelper testOutput)
+                : FormattingTestBase(context, fixture.Service, testOutput), IClassFixture<FormattingTestContext>
+            {
+            """;
+
+        //lang=C#-test
+        var fileFooter = """
+            }
+            """;
+
+        //lang=C#-test
+        var testTemplate = """"
+            [FormattingTestFact]
+            public async Task {TestName}()
+            {
+                await RunFormattingTestAsync(
+                    input: """
+                        @code
+                        {
+                        private bool IconMenuActive { get; set; } = false;
+                        protected void ToggleIconMenu(bool iconMenuActive)
+                        {
+                        IconMenuActive = iconMenuActive;
+                        }
+                        }
+                        """,
+                    expected: """
+                        @code
+                        {
+                            private bool IconMenuActive { get; set; } = false;
+                            protected void ToggleIconMenu(bool iconMenuActive)
+                            {
+                                IconMenuActive = iconMenuActive;
+                            }
+                        }
+                        """,
+                    formattingOptionsOverride: RazorCSharpSyntaxFormattingOptions.Default with
+                    {
+                        NewLines = {RazorNewLinePlacement},
+                        WrappingKeepStatementsOnSingleLine = {WrappingKeepStatementsOnSingleLine},
+                        WrappingPreserveSingleLine = {WrappingPreserveSingleLine},
+                    });
+            }
+        """";
+
+        bool[] booleanOptions = [true, false];
+
+        var projectPath = TestProject.GetProjectDirectory(typeof(CSharpSyntaxFormattingOptionsTest_Generator), layer: TestProject.Layer.Tooling);
+        var testFileName = Path.Combine(projectPath, """Cohost\Formatting\CSharpSyntaxFormattingOptionsTest.cs""");
+
+        var addExtraLine = false;
+
+        using var writer = new StreamWriter(testFileName);
+        writer.WriteLine(fileHeader);
+
+        foreach (var nl in GetAllValues(typeof(RazorNewLinePlacement)))
+            foreach (var keep in booleanOptions)
+                foreach (var preserve in booleanOptions)
+                {
+                    if (addExtraLine)
+                    {
+                        writer.WriteLine();
+                    }
+
+                    addExtraLine = true;
+
+                    var testName = $"CSharpSyntaxFormattingOptions_Without{nl.without}_{(keep ? "SingleLine" : "MultiLine")}_{(preserve ? "PreserveSingle" : "DontPreserve")}";
+                    writer.WriteLine(testTemplate
+                        .Replace("{TestName}", testName)
+                        .Replace("{RazorNewLinePlacement}", nl.value)
+                        .Replace("{WrappingKeepStatementsOnSingleLine}", keep.ToString().ToLowerInvariant())
+                        .Replace("{WrappingPreserveSingleLine}", preserve.ToString().ToLowerInvariant()));
+                }
+
+        writer.WriteLine(fileFooter);
+    }
+
+    private static IEnumerable<(string without, string value)> GetAllValues(Type enumType)
+    {
+        var names = Enum.GetNames(enumType).Where(n => n != "None").ToArray();
+
+        foreach (var name in names)
+        {
+            yield return (name, string.Join(" | ", names.Where(n => n != name).Select(n => $"{enumType.Name}.{n}")));
+        }
+    }
+}
diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs
new file mode 100644
index 00000000000..36c15b6c682
--- /dev/null
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs
@@ -0,0 +1,19 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Razor.Test.Common;
+
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public class ManualRunOnlyFactAttribute : FactAttribute
+{
+    public ManualRunOnlyFactAttribute()
+    {
+        if (Environment.GetEnvironmentVariable("_IntegrationTestsRunningInCI") is not null)
+        {
+            Skip = "This test can only run manually";
+        }
+    }
+}

From aafa1e7ba0cf97b1ec963841af405ecb219f6cd7 Mon Sep 17 00:00:00 2001
From: David Wengier <david.wengier@microsoft.com>
Date: Mon, 23 Jun 2025 19:38:12 +1000
Subject: [PATCH 6/6] Fix header

---
 .../ManualRunOnlyFactAttribute.cs                             | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs
index 36c15b6c682..2f41d592904 100644
--- a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs
+++ b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/ManualRunOnlyFactAttribute.cs
@@ -1,5 +1,5 @@
-// Copyright (c) .NET Foundation. All rights reserved.
-// Licensed under the MIT license. See License.txt in the project root for license information.
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
 using Xunit;