diff --git a/.editorconfig b/.editorconfig
index 69718aea09..034defa6af 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -35,6 +35,7 @@ roslynator_use_var_instead_of_implicit_object_creation = true
 roslynator_infinite_loop_style = while
 roslynator_doc_comment_summary_style = multi_line
 roslynator_enum_flag_value_style = shift_operator
+roslynator_blank_line_after_file_scoped_namespace_declaration = true
 
 csharp_style_namespace_declarations = file_scoped:suggestion
 
@@ -77,6 +78,7 @@ dotnet_diagnostic.RCS0055.severity = suggestion
 dotnet_diagnostic.RCS0057.severity = suggestion
 dotnet_diagnostic.RCS0058.severity = suggestion
 dotnet_diagnostic.RCS0059.severity = suggestion
+dotnet_diagnostic.RCS0060.severity = suggestion
 dotnet_diagnostic.RCS1002.severity = silent
 dotnet_diagnostic.RCS1006.severity = suggestion
 dotnet_diagnostic.RCS1008.severity = suggestion
diff --git a/ChangeLog.md b/ChangeLog.md
index f469b88c58..3fd2e4d0fb 100644
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add Arm64 VS 2022 extension support ([#990](https://github.com/JosefPihrt/Roslynator/pull/990) by @snickler).
+- Add analyzer "Add/remove blank line after file scoped namespace declaration" [RCS0060](https://github.com/JosefPihrt/Roslynator/blob/main/docs/analyzers/RCS0060.md) ([#993](https://github.com/josefpihrt/roslynator/pull/993).
+  - Required option: `roslynator_blank_line_after_file_scoped_namespace_declaration = true|false`
 
 ### Changed
 
diff --git a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
index 00b07a66da..1cbf76a43f 100644
--- a/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
+++ b/src/Common/CSharp/Extensions/CodeStyleExtensions.cs
@@ -495,6 +495,16 @@ public static BodyStyle GetBodyStyle(this SyntaxNodeAnalysisContext context)
         return null;
     }
 
+    public static BlankLineStyle GetBlankLineAfterFileScopedNamespaceDeclaration(this SyntaxNodeAnalysisContext context)
+    {
+        if (ConfigOptions.TryGetValueAsBool(context.GetConfigOptions(), ConfigOptions.BlankLineAfterFileScopedNamespaceDeclaration, out bool value))
+        {
+            return (value) ? BlankLineStyle.Add : BlankLineStyle.Remove;
+        }
+
+        return BlankLineStyle.None;
+    }
+
     public static bool? GetSuppressUnityScriptMethods(this SyntaxNodeAnalysisContext context)
     {
         if (ConfigOptions.TryGetValueAsBool(context.GetConfigOptions(), ConfigOptions.SuppressUnityScriptMethods, out bool value))
diff --git a/src/Common/ConfigOptionKeys.Generated.cs b/src/Common/ConfigOptionKeys.Generated.cs
index 88def25b2f..18b43bc31c 100644
--- a/src/Common/ConfigOptionKeys.Generated.cs
+++ b/src/Common/ConfigOptionKeys.Generated.cs
@@ -11,6 +11,7 @@ internal static partial class ConfigOptionKeys
         public const string ArrayCreationTypeStyle                            = "roslynator_array_creation_type_style";
         public const string ArrowTokenNewLine                                 = "roslynator_arrow_token_new_line";
         public const string BinaryOperatorNewLine                             = "roslynator_binary_operator_new_line";
+        public const string BlankLineAfterFileScopedNamespaceDeclaration      = "roslynator_blank_line_after_file_scoped_namespace_declaration";
         public const string BlankLineBetweenClosingBraceAndSwitchSection      = "roslynator_blank_line_between_closing_brace_and_switch_section";
         public const string BlankLineBetweenSingleLineAccessors               = "roslynator_blank_line_between_single_line_accessors";
         public const string BlankLineBetweenUsingDirectives                   = "roslynator_blank_line_between_using_directives";
diff --git a/src/Common/ConfigOptions.Generated.cs b/src/Common/ConfigOptions.Generated.cs
index 4e8be78351..755d624575 100644
--- a/src/Common/ConfigOptions.Generated.cs
+++ b/src/Common/ConfigOptions.Generated.cs
@@ -38,6 +38,12 @@ public static partial class ConfigOptions
             defaultValuePlaceholder: "after|before", 
             description:             "Place new line after/before binary operator");
 
+        public static readonly ConfigOptionDescriptor BlankLineAfterFileScopedNamespaceDeclaration = new(
+            key:                     ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, 
+            defaultValue:            null, 
+            defaultValuePlaceholder: "true|false", 
+            description:             "Add/remove blank line after file scoped namespace declaration");
+
         public static readonly ConfigOptionDescriptor BlankLineBetweenClosingBraceAndSwitchSection = new(
             key:                     ConfigOptionKeys.BlankLineBetweenClosingBraceAndSwitchSection, 
             defaultValue:            null, 
@@ -213,6 +219,7 @@ public static partial class ConfigOptions
             yield return new KeyValuePair<string, string>("RCS0052", JoinOptionKeys(ConfigOptionKeys.EqualsTokenNewLine));
             yield return new KeyValuePair<string, string>("RCS0058", JoinOptionKeys(ConfigOptionKeys.NewLineAtEndOfFile));
             yield return new KeyValuePair<string, string>("RCS0059", JoinOptionKeys(ConfigOptionKeys.NullConditionalOperatorNewLine));
+            yield return new KeyValuePair<string, string>("RCS0060", JoinOptionKeys(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration));
             yield return new KeyValuePair<string, string>("RCS1014", JoinOptionKeys(ConfigOptionKeys.ArrayCreationTypeStyle));
             yield return new KeyValuePair<string, string>("RCS1016", JoinOptionKeys(ConfigOptionKeys.BodyStyle, ConfigOptionKeys.UseBlockBodyWhenDeclarationSpansOverMultipleLines, ConfigOptionKeys.UseBlockBodyWhenExpressionSpansOverMultipleLines));
             yield return new KeyValuePair<string, string>("RCS1018", JoinOptionKeys(ConfigOptionKeys.AccessibilityModifiers));
diff --git a/src/Common/ConfigOptions.xml b/src/Common/ConfigOptions.xml
index 303a6fa295..e571fe5d67 100644
--- a/src/Common/ConfigOptions.xml
+++ b/src/Common/ConfigOptions.xml
@@ -195,6 +195,10 @@
     </Values>
     <Description>Use 'for'/'while' statement as an infinite loop</Description>
   </Option>
+  <Option Id="BlankLineAfterFileScopedNamespaceDeclaration">
+    <ValuePlaceholder>true|false</ValuePlaceholder>
+    <Description>Add/remove blank line after file scoped namespace declaration</Description>
+  </Option>
   <!--
   <Option Id="">
     <Key></Key>
diff --git a/src/Formatting.Analyzers.CodeFixes/CSharp/FileScopedNamespaceDeclarationCodeFixProvider.cs b/src/Formatting.Analyzers.CodeFixes/CSharp/FileScopedNamespaceDeclarationCodeFixProvider.cs
new file mode 100644
index 0000000000..603ef37ebf
--- /dev/null
+++ b/src/Formatting.Analyzers.CodeFixes/CSharp/FileScopedNamespaceDeclarationCodeFixProvider.cs
@@ -0,0 +1,76 @@
+// Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Roslynator.CSharp;
+using Roslynator.Formatting.CSharp;
+using Roslynator.CSharp.CodeStyle;
+using System.Diagnostics;
+
+namespace Roslynator.Formatting.CodeFixes.CSharp;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(FileScopedNamespaceDeclarationCodeFixProvider))]
+[Shared]
+public sealed class FileScopedNamespaceDeclarationCodeFixProvider : BaseCodeFixProvider
+{
+    public override ImmutableArray<string> FixableDiagnosticIds
+    {
+        get { return ImmutableArray.Create(DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration); }
+    }
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
+
+        if (!TryFindFirstAncestorOrSelf(root, context.Span, out FileScopedNamespaceDeclarationSyntax fileScopedNamespace))
+            return;
+
+        Document document = context.Document;
+        Diagnostic diagnostic = context.Diagnostics[0];
+        MemberDeclarationSyntax member = fileScopedNamespace.Members[0];
+        BlankLineStyle style = BlankLineAfterFileScopedNamespaceDeclarationAnalyzer.GetCurrentStyle(fileScopedNamespace, member);
+
+        if (style == BlankLineStyle.Add)
+        {
+            CodeAction codeAction = CodeAction.Create(
+                CodeFixTitles.AddBlankLine,
+                ct =>
+                {
+                    MemberDeclarationSyntax newMember;
+                    if (!fileScopedNamespace.SemicolonToken.TrailingTrivia.Contains(SyntaxKind.EndOfLineTrivia))
+                    {
+                        newMember = member.PrependToLeadingTrivia(new SyntaxTrivia[] { CSharpFactory.NewLine(), CSharpFactory.NewLine() });
+                    }
+                    else
+                    {
+                        newMember = member.PrependEndOfLineToLeadingTrivia();
+                    }
+
+                    return document.ReplaceNodeAsync(member, newMember, ct);
+                },
+                GetEquivalenceKey(diagnostic));
+
+            context.RegisterCodeFix(codeAction, diagnostic);
+        }
+        else if (style == BlankLineStyle.Remove)
+        {
+            CodeAction codeAction = CodeAction.Create(
+                CodeFixTitles.RemoveBlankLine,
+                ct => CodeFixHelpers.RemoveBlankLinesBeforeAsync(document, member.GetFirstToken(), ct),
+                GetEquivalenceKey(diagnostic));
+
+            context.RegisterCodeFix(codeAction, diagnostic);
+        }
+        else
+        {
+            Debug.Fail("");
+        }
+    }
+}
diff --git a/src/Formatting.Analyzers/CSharp/BlankLineAfterFileScopedNamespaceDeclarationAnalyzer.cs b/src/Formatting.Analyzers/CSharp/BlankLineAfterFileScopedNamespaceDeclarationAnalyzer.cs
new file mode 100644
index 0000000000..83bc137444
--- /dev/null
+++ b/src/Formatting.Analyzers/CSharp/BlankLineAfterFileScopedNamespaceDeclarationAnalyzer.cs
@@ -0,0 +1,135 @@
+// Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+using Roslynator.CSharp;
+using Roslynator.CSharp.CodeStyle;
+
+namespace Roslynator.Formatting.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class BlankLineAfterFileScopedNamespaceDeclarationAnalyzer : BaseDiagnosticAnalyzer
+{
+    private static ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics;
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+    {
+        get
+        {
+            if (_supportedDiagnostics.IsDefault)
+                Immutable.InterlockedInitialize(ref _supportedDiagnostics, DiagnosticRules.BlankLineAfterFileScopedNamespaceDeclaration);
+
+            return _supportedDiagnostics;
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+
+        context.RegisterSyntaxNodeAction(f => AnalyzeFileScopedNamespaceDeclaration(f), SyntaxKind.FileScopedNamespaceDeclaration);
+    }
+
+    private static void AnalyzeFileScopedNamespaceDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var namespaceDeclaration = (FileScopedNamespaceDeclarationSyntax)context.Node;
+
+        MemberDeclarationSyntax memberDeclaration = namespaceDeclaration.Members.FirstOrDefault();
+
+        if (memberDeclaration is null)
+            return;
+
+        BlankLineStyle style = context.GetBlankLineAfterFileScopedNamespaceDeclaration();
+
+        if (style == BlankLineStyle.None)
+            return;
+
+        BlankLineStyle currentStyle = GetCurrentStyle(namespaceDeclaration, memberDeclaration);
+
+        if (style != currentStyle)
+            return;
+
+        context.ReportDiagnostic(
+            DiagnosticRules.BlankLineAfterFileScopedNamespaceDeclaration,
+            Location.Create(namespaceDeclaration.SyntaxTree, new TextSpan(memberDeclaration.FullSpan.Start, 0)),
+            (style == BlankLineStyle.Add) ? "Add" : "Remove");
+    }
+
+    internal static BlankLineStyle GetCurrentStyle(
+        FileScopedNamespaceDeclarationSyntax namespaceDeclaration,
+        MemberDeclarationSyntax memberDeclaration)
+    {
+        (bool add, bool remove) = AnalyzeTrailingTrivia();
+
+        if (add || remove)
+        {
+            BlankLineStyle style = AnalyzeLeadingTrivia();
+
+            if (style == BlankLineStyle.Add)
+            {
+                if (add)
+                    return style;
+            }
+            else if (style == BlankLineStyle.Remove)
+            {
+                if (remove)
+                    return style;
+            }
+        }
+
+        return BlankLineStyle.None;
+
+        (bool add, bool remove) AnalyzeTrailingTrivia()
+        {
+            SyntaxTriviaList.Enumerator en = namespaceDeclaration.SemicolonToken.TrailingTrivia.GetEnumerator();
+
+            if (!en.MoveNext())
+                return (true, false);
+
+            if (en.Current.IsWhitespaceTrivia()
+                && !en.MoveNext())
+            {
+                return (true, false);
+            }
+
+            if (en.Current.IsKind(SyntaxKind.SingleLineCommentTrivia)
+                && !en.MoveNext())
+            {
+                return (true, false);
+            }
+
+            return (en.Current.IsEndOfLineTrivia())
+                ? (true, true)
+                : (false, false);
+        }
+
+        BlankLineStyle AnalyzeLeadingTrivia()
+        {
+            SyntaxTriviaList.Enumerator en = memberDeclaration.GetLeadingTrivia().GetEnumerator();
+
+            if (!en.MoveNext())
+                return BlankLineStyle.Add;
+
+            if (en.Current.IsWhitespaceTrivia()
+                && !en.MoveNext())
+            {
+                return BlankLineStyle.Add;
+            }
+
+            switch (en.Current.Kind())
+            {
+                case SyntaxKind.SingleLineCommentTrivia:
+                case SyntaxKind.SingleLineDocumentationCommentTrivia:
+                    return BlankLineStyle.Add;
+                case SyntaxKind.EndOfLineTrivia:
+                    return BlankLineStyle.Remove;
+            }
+
+            return BlankLineStyle.None;
+        }
+    }
+}
diff --git a/src/Formatting.Analyzers/CSharp/DiagnosticIdentifiers.Generated.cs b/src/Formatting.Analyzers/CSharp/DiagnosticIdentifiers.Generated.cs
index e9858c2e95..65967216a0 100644
--- a/src/Formatting.Analyzers/CSharp/DiagnosticIdentifiers.Generated.cs
+++ b/src/Formatting.Analyzers/CSharp/DiagnosticIdentifiers.Generated.cs
@@ -59,5 +59,6 @@ public static partial class DiagnosticIdentifiers
         public const string NormalizeWhitespaceAtBeginningOfFile = "RCS0057";
         public const string NormalizeWhitespaceAtEndOfFile = "RCS0058";
         public const string PlaceNewLineAfterOrBeforeNullConditionalOperator = "RCS0059";
+        public const string BlankLineAfterFileScopedNamespaceDeclaration = "RCS0060";
     }
 }
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/CSharp/DiagnosticRules.Generated.cs b/src/Formatting.Analyzers/CSharp/DiagnosticRules.Generated.cs
index 61e942bc3a..589aaeaaf6 100644
--- a/src/Formatting.Analyzers/CSharp/DiagnosticRules.Generated.cs
+++ b/src/Formatting.Analyzers/CSharp/DiagnosticRules.Generated.cs
@@ -621,5 +621,17 @@ public static partial class DiagnosticRules
             helpLinkUri:        DiagnosticIdentifiers.PlaceNewLineAfterOrBeforeNullConditionalOperator, 
             customTags:         Array.Empty<string>());
 
+        /// <summary>RCS0060</summary>
+        public static readonly DiagnosticDescriptor BlankLineAfterFileScopedNamespaceDeclaration = DiagnosticDescriptorFactory.Create(
+            id:                 DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration, 
+            title:              "Add/remove line after file scoped namespace declaration.", 
+            messageFormat:      "{0} line after file scoped namespace declaration.", 
+            category:           DiagnosticCategories.Roslynator, 
+            defaultSeverity:    DiagnosticSeverity.Info, 
+            isEnabledByDefault: false, 
+            description:        null, 
+            helpLinkUri:        DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration, 
+            customTags:         Array.Empty<string>());
+
     }
 }
\ No newline at end of file
diff --git a/src/Formatting.Analyzers/Formatting.Analyzers.xml b/src/Formatting.Analyzers/Formatting.Analyzers.xml
index 77981e6528..6fe4914bd2 100644
--- a/src/Formatting.Analyzers/Formatting.Analyzers.xml
+++ b/src/Formatting.Analyzers/Formatting.Analyzers.xml
@@ -1481,4 +1481,35 @@ Default maximal length is 140.</Summary>
       <Option Key="null_conditional_operator_new_line" IsRequired="true" />
     </ConfigOptions>
   </Analyzer>
+  <Analyzer Identifier="BlankLineAfterFileScopedNamespaceDeclaration">
+    <Id>RCS0060</Id>
+    <Title>Add/remove line after file scoped namespace declaration.</Title>
+    <MessageFormat>{0} line after file scoped namespace declaration.</MessageFormat>
+    <Category>Formatting</Category>
+    <DefaultSeverity>Info</DefaultSeverity>
+    <IsEnabledByDefault>false</IsEnabledByDefault>
+    <MinLanguageVersion>10.0</MinLanguageVersion>
+    <Samples>
+      <Sample>
+        <Before><![CDATA[namespace A.B // [|Id|]
+public class C
+{
+}]]></Before>
+        <After><![CDATA[namespace A.B
+
+public class C
+{
+}]]></After>
+      </Sample>
+    </Samples>
+    <ConfigOptions>
+      <Option Key="blank_line_after_file_scoped_namespace_declaration" IsRequired="true" />
+    </ConfigOptions>
+    <Links>
+      <Link>
+        <Url>https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/file-scoped-namespaces</Url>
+        <Text>File Scoped Namespaces</Text>
+      </Link>
+    </Links>
+  </Analyzer>
 </Analyzers>
\ No newline at end of file
diff --git a/src/Tests/Formatting.Analyzers.Tests/RCS0060AddEmptyLineAfterFileScopedNamespaceTests.cs b/src/Tests/Formatting.Analyzers.Tests/RCS0060AddEmptyLineAfterFileScopedNamespaceTests.cs
new file mode 100644
index 0000000000..7465958b65
--- /dev/null
+++ b/src/Tests/Formatting.Analyzers.Tests/RCS0060AddEmptyLineAfterFileScopedNamespaceTests.cs
@@ -0,0 +1,259 @@
+// Copyright (c) Josef Pihrt and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Roslynator.Formatting.CodeFixes.CSharp;
+using Roslynator.Testing.CSharp;
+using Xunit;
+
+namespace Roslynator.Formatting.CSharp.Tests;
+
+public class RCS0060BlankLineAfterFileScopedNamespaceDeclarationTests : AbstractCSharpDiagnosticVerifier<BlankLineAfterFileScopedNamespaceDeclarationAnalyzer, FileScopedNamespaceDeclarationCodeFixProvider>
+{
+    public override DiagnosticDescriptor Descriptor { get; } = DiagnosticRules.BlankLineAfterFileScopedNamespaceDeclaration;
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]class C
+{
+}
+", @"
+namespace A.B;
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine2()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;  
+[||]class C
+{
+}
+", @"
+namespace A.B;  
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine3()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;  //x
+[||]class C
+{
+}
+", @"
+namespace A.B;  //x
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine4()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;//x
+[||]class C
+{
+}
+", @"
+namespace A.B;//x
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine5()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;[||]class C
+{
+}
+", @"
+namespace A.B;
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine6()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;  [||]class C
+{
+}
+", @"
+namespace A.B;  
+
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine7()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]  class C
+{
+}
+", @"
+namespace A.B;
+
+  class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine8()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]/// <summary>
+/// 
+/// </summary>
+class C
+{
+}
+", @"
+namespace A.B;
+
+/// <summary>
+/// 
+/// </summary>
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_AddEmptyLine9()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]// x
+class C
+{
+}
+", @"
+namespace A.B;
+
+// x
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, true));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_RemoveEmptyLine()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]
+class C
+{
+}
+", @"
+namespace A.B;
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_RemoveEmptyLine2()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;  
+[||]
+class C
+{
+}
+", @"
+namespace A.B;  
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_RemoveEmptyLine3()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;  //x
+[||]
+class C
+{
+}
+", @"
+namespace A.B;  //x
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_RemoveEmptyLine4()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;//x
+[||]
+class C
+{
+}
+", @"
+namespace A.B;//x
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, false));
+    }
+
+    [Fact, Trait(Traits.Analyzer, DiagnosticIdentifiers.BlankLineAfterFileScopedNamespaceDeclaration)]
+    public async Task Test_RemoveEmptyLine5()
+    {
+        await VerifyDiagnosticAndFixAsync(@"
+namespace A.B;
+[||]
+
+class C
+{
+}
+", @"
+namespace A.B;
+class C
+{
+}
+", options: Options.AddConfigOption(ConfigOptionKeys.BlankLineAfterFileScopedNamespaceDeclaration, false));
+    }
+}