File: EncapsulateField\EncapsulateFieldTests.cs
Web Access
Project: src\src\Features\CSharpTest\Microsoft.CodeAnalysis.CSharp.Features.UnitTests.csproj (Microsoft.CodeAnalysis.CSharp.Features.UnitTests)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.CodeStyle;
using Microsoft.CodeAnalysis.CSharp.CodeStyle;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.EncapsulateField;
using Microsoft.CodeAnalysis.Remote.Testing;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.EncapsulateField;
 
[Trait(Traits.Feature, Traits.Features.EncapsulateField)]
public sealed class EncapsulateFieldTests : AbstractCSharpCodeActionTest_NoEditor
{
    protected override CodeRefactoringProvider CreateCodeRefactoringProvider(TestWorkspace workspace, TestParameters parameters)
        => new EncapsulateFieldRefactoringProvider();
 
    private OptionsCollection AllOptionsOff
        => new(GetLanguage())
        {
            { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
            { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement },
        };
 
    internal Task TestAllOptionsOffAsync(
        TestHost host,
        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string initialMarkup,
        [StringSyntax(PredefinedEmbeddedLanguageNames.CSharpTest)] string expectedMarkup,
        ParseOptions? parseOptions = null,
        CompilationOptions? compilationOptions = null,
        int index = 0,
        OptionsCollection? options = null)
    {
        options ??= new OptionsCollection(GetLanguage());
        options.AddRange(AllOptionsOff);
 
        return TestAsync(initialMarkup, expectedMarkup, parseOptions, compilationOptions, index, options, testHost: host);
    }
 
    [Theory, CombinatorialData]
    public async Task PrivateFieldToPropertyIgnoringReferences(TestHost host)
    {
        var text = """
            class goo
            {
                private int b[|a|]r;
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData]
    public async Task PrivateNullableFieldToPropertyIgnoringReferences(TestHost host)
    {
        var text = """
            #nullable enable
            class goo
            {
                private string? b[|a|]r;
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
 
        var expected = """
            #nullable enable
            class goo
            {
                private string? bar;
 
                public string? Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData]
    public async Task PrivateFieldToPropertyUpdatingReferences(TestHost host)
    {
        var text = """
            class goo
            {
                private int b[|a|]r;
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task TestCodeStyle1(TestHost host)
    {
        var text = """
            class goo
            {
                private int b[|a|]r;
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
        await TestInRegularAndScriptAsync(text, expected,
            options: new OptionsCollection(GetLanguage())
            {
                { CSharpCodeStyleOptions.PreferExpressionBodiedProperties, ExpressionBodyPreference.WhenPossible, NotificationOption2.Silent },
                { CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, ExpressionBodyPreference.Never, NotificationOption2.Silent }
            },
            testHost: host);
    }
 
    [Theory, CombinatorialData]
    public async Task TestCodeStyle2(TestHost host)
    {
        var text = """
            class goo
            {
                private int b[|a|]r;
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar { get => bar; set => bar = value; }
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
        await TestInRegularAndScriptAsync(text, expected,
            options: new OptionsCollection(GetLanguage())
            {
                {  CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.WhenPossibleWithSilentEnforcement },
            },
            testHost: host);
    }
 
    [Theory, CombinatorialData]
    public async Task PublicFieldIntoPublicPropertyIgnoringReferences(TestHost host)
    {
        var text = """
            class goo
            {
                public int b[|a|]r;
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData]
    public async Task PublicFieldIntoPublicPropertyUpdatingReferences(TestHost host)
    {
        var text = """
            class goo
            {
                public int b[|a|]r;
 
                void baz()
                {
                    var q = bar;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int bar;
 
                public int Bar
                {
                    get
                    {
                        return bar;
                    }
 
                    set
                    {
                        bar = value;
                    }
                }
 
                void baz()
                {
                    var q = Bar;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task StaticPreserved(TestHost host)
    {
        var text = """
            class Program
            {
                static int [|goo|];
            }
            """;
 
        var expected = """
            class Program
            {
                static int goo;
 
                public static int Goo
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected);
    }
 
    [Theory, CombinatorialData]
    public async Task UniqueNameGenerated(TestHost host)
    {
        var text = """
            class Program
            {
                [|int goo|];
                string Goo;
            }
            """;
 
        var expected = """
            class Program
            {
                int goo;
                string Goo;
 
                public int Goo1
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected);
    }
 
    [Theory, CombinatorialData]
    public async Task GenericField(TestHost host)
    {
        var text = """
            class C<T>
            {
                private [|T goo|];
            }
            """;
 
        var expected = """
            class C<T>
            {
                private T goo;
 
                public T Goo
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected);
    }
 
    [Theory, CombinatorialData]
    public async Task NewFieldNameIsUnique(TestHost host)
    {
        var text = """
            class goo
            {
                public [|int X|];
                private string x;
            }
            """;
 
        var expected = """
            class goo
            {
                private int x1;
                private string x;
 
                public int X
                {
                    get
                    {
                        return x1;
                    }
 
                    set
                    {
                        x1 = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task RespectReadonly(TestHost host)
    {
        var text = """
            class goo
            {
                private readonly [|int x|];
            }
            """;
 
        var expected = """
            class goo
            {
                private readonly int x;
 
                public int X
                {
                    get
                    {
                        return x;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task PreserveNewAndConsiderBaseMemberNames(TestHost host)
    {
        var text = """
            class c
            {
                protected int goo;
 
                protected int Goo { get; set; }
            }
 
            class d : c
            {
                protected new int [|goo|];
            }
            """;
 
        var expected = """
            class c
            {
                protected int goo;
 
                protected int Goo { get; set; }
            }
 
            class d : c
            {
                private new int goo;
 
                protected int Goo1
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task EncapsulateMultiplePrivateFields(TestHost host)
    {
        var text = """
            class goo
            {
                private int [|x, y|];
 
                void bar()
                {
                    x = 1;
                    y = 2;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int x, y;
 
                public int X
                {
                    get
                    {
                        return x;
                    }
 
                    set
                    {
                        x = value;
                    }
                }
 
                public int Y
                {
                    get
                    {
                        return y;
                    }
 
                    set
                    {
                        y = value;
                    }
                }
 
                void bar()
                {
                    X = 1;
                    Y = 2;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task EncapsulateMultiplePrivateFields2(TestHost host)
    {
        var text = """
            class goo
            {
                [|private int x;
                private int y|];
 
                void bar()
                {
                    x = 1;
                    y = 2;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                private int x;
                private int y;
 
                public int X
                {
                    get
                    {
                        return x;
                    }
 
                    set
                    {
                        x = value;
                    }
                }
 
                public int Y
                {
                    get
                    {
                        return y;
                    }
 
                    set
                    {
                        y = value;
                    }
                }
 
                void bar()
                {
                    X = 1;
                    Y = 2;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task EncapsulateSinglePublicFieldInMultipleVariableDeclarationAndUpdateReferences(TestHost host)
    {
        var text = """
            class goo
            {
                public int [|x|], y;
 
                void bar()
                {
                    x = 1;
                    y = 2;
                }
            }
            """;
 
        var expected = """
            class goo
            {
                public int y;
                private int x;
 
                public int X
                {
                    get
                    {
                        return x;
                    }
 
                    set
                    {
                        x = value;
                    }
                }
 
                void bar()
                {
                    X = 1;
                    y = 2;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/694057"), CombinatorialData]
    public async Task ConstFieldNoGetter(TestHost host)
    {
        var text = """
            class Program
            {
                private const int [|bar|] = 3;
            }
            """;
 
        var expected = """
            class Program
            {
                private const int bar = 3;
 
                public static int Bar
                {
                    get
                    {
                        return bar;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/694276"), CombinatorialData]
    public async Task EncapsulateFieldNamedValue(TestHost host)
    {
        var text = """
            class Program
            {
                private const int [|bar|] = 3;
            }
            """;
 
        var expected = """
            class Program
            {
                private const int bar = 3;
 
                public static int Bar
                {
                    get
                    {
                        return bar;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/694276"), CombinatorialData]
    public async Task PublicFieldNamed__(TestHost host)
    {
        var text = """
            class Program
            {
                public int [|__|];
            }
            """;
 
        var expected = """
            class Program
            {
                private int __1;
 
                public int __
                {
                    get
                    {
                        return __1;
                    }
 
                    set
                    {
                        __1 = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/695046"), CombinatorialData]
    public async Task AvailableNotJustOnVariableName(TestHost host)
    {
        var text = """
            class Program
            {
                pri[||]vate int x;
            }
            """;
 
        await TestActionCountAsync(text, 2, new TestParameters(testHost: host));
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/705898"), CombinatorialData]
    public async Task CopyFieldAccessibility(TestHost host)
    {
        var text = """
            class Program
            {
                protected const int [|bar|] = 3;
            }
            """;
 
        var expected = """
            class Program
            {
                private const int bar = 3;
 
                protected static int Bar
                {
                    get
                    {
                        return bar;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, CombinatorialData]
    public async Task UpdateReferencesCrossProject(TestHost host)
    {
        var text = """
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            public class C
            {
                public int [|goo|];
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <ProjectReference>Assembly1</ProjectReference>
                    <Document>
            public class D
            {
                void bar()
                {
                    var c = new C;
                    c.goo = 3;
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """;
 
        var expected = """
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            public class C
            {
                private int goo;
 
                public int Goo
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <ProjectReference>Assembly1</ProjectReference>
                    <Document>
            public class D
            {
                void bar()
                {
                    var c = new C;
                    c.Goo = 3;
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """;
        await TestAllOptionsOffAsync(host, text, expected, new CodeAnalysis.CSharp.CSharpParseOptions(), TestOptions.ReleaseExe);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713269"), CombinatorialData]
    public async Task PreserveUnsafe(TestHost host)
    {
        var text = """
            class C
            {
                unsafe int* [|goo|];
            }
            """;
 
        var expected = """
            class C
            {
                unsafe int* goo;
 
                public unsafe int* Goo
                {
                    get
                    {
                        return goo;
                    }
 
                    set
                    {
                        goo = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713240"), CombinatorialData]
    public async Task ConsiderReturnTypeAccessibility(TestHost host)
    {
        var text = """
            public class Program
            {
                private State [|state|];
            }
 
            internal enum State
            {
                WA
            }
            """;
 
        var expected = """
            public class Program
            {
                private State state;
 
                internal State State
                {
                    get
                    {
                        return state;
                    }
 
                    set
                    {
                        state = value;
                    }
                }
            }
 
            internal enum State
            {
                WA
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713191"), CombinatorialData]
    public async Task DoNotReferToReadOnlyPropertyInConstructor(TestHost host)
    {
        var text = """
            class Program
            {
                public readonly int [|Field|];
 
                public Program(int f)
                {
                    this.Field = f;
                }
            }
            """;
 
        var expected = """
            class Program
            {
                private readonly int field;
 
                public Program(int f)
                {
                    this.field = f;
                }
 
                public int Field
                {
                    get
                    {
                        return field;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/713191"), CombinatorialData]
    public async Task DoNotReferToStaticReadOnlyPropertyInConstructor(TestHost host)
    {
        var text = """
            class Program
            {
                public static readonly int [|Field|];
 
                static Program()
                {
                    Field = 3;
                }
            }
            """;
 
        var expected = """
            class Program
            {
                private static readonly int field;
 
                static Program()
                {
                    field = 3;
                }
 
                public static int Field
                {
                    get
                    {
                        return field;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 0);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/765959"), CombinatorialData]
    public async Task GenerateInTheCorrectPart(TestHost host)
    {
        var text = """
            partial class Program {}
 
            partial class Program {
               private int [|x|];
            }
            """;
        var expected = """
            partial class Program {}
 
            partial class Program {
               private int x;
 
                public int X
                {
                    get
                    {
                        return x;
                    }
 
                    set
                    {
                        x = value;
                    }
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected);
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/829178"), CombinatorialData]
    public async Task ErrorTolerance(TestHost host)
    {
        var text = """
            class Program 
            {
                a b c [|b|]
            }
            """;
 
        await TestActionCountAsync(text, count: 2, new TestParameters(testHost: host));
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/834072"), CombinatorialData]
    public async Task DuplicateFieldErrorTolerance(TestHost host)
    {
        var text = """
            class Program
            {
                public const string [|s|] = "S";
                public const string s = "S";
            }
            """;
 
        await TestActionCountAsync(text, count: 2, new TestParameters(testHost: host));
    }
 
    [Theory, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/862517"), CombinatorialData]
    public async Task Trivia(TestHost host)
    {
        var text = """
            namespace ConsoleApplication1
            {
                class Program
                {
                    // Some random comment
                    public int myI[||]nt;
                }
            }
            """;
 
        var expected = """
            namespace ConsoleApplication1
            {
                class Program
                {
                    // Some random comment
                    private int myInt;
 
                    public int MyInt
                    {
                        get
                        {
                            return myInt;
                        }
 
                        set
                        {
                            myInt = value;
                        }
                    }
                }
            }
            """;
 
        await TestAllOptionsOffAsync(host, text, expected);
    }
 
    [Theory, WorkItem(1096007, "https://github.com/dotnet/roslyn/issues/282"), CombinatorialData]
    public async Task DoNotEncapsulateOutsideTypeDeclaration(TestHost host)
    {
        await TestMissingInRegularAndScriptAsync(
@"var [|x|] = 1;", new TestParameters(testHost: host));
 
        await TestMissingInRegularAndScriptAsync(
            """
            namespace N
            {
                var [|x|] = 1;
            }
            """, new TestParameters(testHost: host));
 
        await TestMissingInRegularAndScriptAsync(
            """
            enum E
            {
                [|x|] = 1;
            }
            """, new TestParameters(testHost: host));
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/5524"), CombinatorialData]
    public async Task AlwaysUseEnglishUSCultureWhenFixingVariableNames_TurkishDottedI(TestHost host)
    {
        using (new CultureContext(new CultureInfo("tr-TR", useUserOverride: false)))
        {
            await TestAllOptionsOffAsync(host,
                """
                class C
                {
                    int [|iyi|];
                }
                """,
                """
                class C
                {
                    int iyi;
 
                    public int Iyi
                    {
                        get
                        {
                            return iyi;
                        }
 
                        set
                        {
                            iyi = value;
                        }
                    }
                }
                """);
        }
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/5524"), CombinatorialData]
    public async Task AlwaysUseEnglishUSCultureWhenFixingVariableNames_TurkishUndottedI(TestHost host)
    {
        using (new CultureContext(new CultureInfo("tr-TR", useUserOverride: false)))
        {
            await TestAllOptionsOffAsync(host,
                """
                class C
                {
                    int [|ırak|];
                }
                """,
                """
                class C
                {
                    int ırak;
 
                    public int Irak
                    {
                        get
                        {
                            return ırak;
                        }
 
                        set
                        {
                            ırak = value;
                        }
                    }
                }
                """);
        }
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/5524"), CombinatorialData]
    public async Task AlwaysUseEnglishUSCultureWhenFixingVariableNames_Arabic(TestHost host)
    {
        using (new CultureContext(new CultureInfo("ar-EG", useUserOverride: false)))
        {
            await TestAllOptionsOffAsync(host,
                """
                class C
                {
                    int [|بيت|];
                }
                """,
                """
                class C
                {
                    int بيت;
 
                    public int بيت1
                    {
                        get
                        {
                            return بيت;
                        }
 
                        set
                        {
                            بيت = value;
                        }
                    }
                }
                """);
        }
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/5524"), CombinatorialData]
    public async Task AlwaysUseEnglishUSCultureWhenFixingVariableNames_Spanish(TestHost host)
    {
        using (new CultureContext(new CultureInfo("es-ES", useUserOverride: false)))
        {
            await TestAllOptionsOffAsync(host,
                """
                class C
                {
                    int [|árbol|];
                }
                """,
                """
                class C
                {
                    int árbol;
 
                    public int Árbol
                    {
                        get
                        {
                            return árbol;
                        }
 
                        set
                        {
                            árbol = value;
                        }
                    }
                }
                """);
        }
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/5524"), CombinatorialData]
    public async Task AlwaysUseEnglishUSCultureWhenFixingVariableNames_Greek(TestHost host)
    {
        using (new CultureContext(new CultureInfo("el-GR", useUserOverride: false)))
        {
            await TestAllOptionsOffAsync(host,
                """
                class C
                {
                    int [|σκύλος|];
                }
                """,
                """
                class C
                {
                    int σκύλος;
 
                    public int Σκύλος
                    {
                        get
                        {
                            return σκύλος;
                        }
 
                        set
                        {
                            σκύλος = value;
                        }
                    }
                }
                """);
        }
    }
 
    [Theory, CombinatorialData]
    public async Task TestEncapsulateEscapedIdentifier(TestHost host)
    {
        await TestAllOptionsOffAsync(host, """
            class C
            {
                int [|@class|];
            }
            """, """
            class C
            {
                int @class;
 
                public int Class
                {
                    get
                    {
                        return @class;
                    }
 
                    set
                    {
                        @class = value;
                    }
                }
            }
            """);
    }
 
    [Theory, CombinatorialData]
    public async Task TestEncapsulateEscapedIdentifierAndQualifiedAccess(TestHost host)
    {
        await TestAllOptionsOffAsync(host, """
            class C
            {
                int [|@class|];
            }
            """, """
            class C
            {
                int @class;
 
                public int Class
                {
                    get
                    {
                        return this.@class;
                    }
 
                    set
                    {
                        this.@class = value;
                    }
                }
            }
            """, options: Option(CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Error));
    }
 
    [Theory, WorkItem("https://github.com/dotnet/roslyn/issues/7090"), CombinatorialData]
    public async Task ApplyCurrentThisPrefixStyle(TestHost host)
    {
        await TestAllOptionsOffAsync(host,
            """
            class C
            {
                int [|i|];
            }
            """,
            """
            class C
            {
                int i;
 
                public int I
                {
                    get
                    {
                        return this.i;
                    }
 
                    set
                    {
                        this.i = value;
                    }
                }
            }
            """, options: Option(CodeStyleOptions2.QualifyFieldAccess, true, NotificationOption2.Error));
    }
 
    [Theory, CombinatorialData, CompilerTrait(CompilerFeature.Tuples)]
    public async Task TestTuple(TestHost host)
    {
        var text = """
            class C
            {
                private (int, string) b[|o|]b;
 
                void M()
                {
                    var q = bob;
                }
            }
            """;
 
        var expected = """
            class C
            {
                private (int, string) bob;
 
                public (int, string) Bob
                {
                    get
                    {
                        return bob;
                    }
 
                    set
                    {
                        bob = value;
                    }
                }
 
                void M()
                {
                    var q = bob;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData, CompilerTrait(CompilerFeature.Tuples)]
    public async Task TupleWithNames(TestHost host)
    {
        var text = """
            class C
            {
                private (int a, string b) b[|o|]b;
 
                void M()
                {
                    var q = bob.b;
                }
            }
            """;
 
        var expected = """
            class C
            {
                private (int a, string b) bob;
 
                public (int a, string b) Bob
                {
                    get
                    {
                        return bob;
                    }
 
                    set
                    {
                        bob = value;
                    }
                }
 
                void M()
                {
                    var q = bob.b;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData, CompilerTrait(CompilerFeature.FunctionPointers)]
    public async Task FunctionPointer(TestHost host)
    {
        var text = """
            unsafe class C
            {
                private delegate*<int, string> f[|i|]eld;
 
                void M()
                {
                    var q = field;
                }
            }
            """;
 
        var expected = """
            unsafe class C
            {
                private delegate*<int, string> f[|i|]eld;
 
                public unsafe delegate*<int, string> Field
                {
                    get
                    {
                        return field;
                    }
 
                    set
                    {
                        field = value;
                    }
                }
 
                void M()
                {
                    var q = field;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData, CompilerTrait(CompilerFeature.FunctionPointers)]
    public async Task FunctionPointerWithPrivateTypeParameter(TestHost host)
    {
        var text = """
            unsafe class C
            {
                private struct S { }
                private delegate*<S, string> f[|i|]eld;
 
                void M()
                {
                    var q = field;
                }
            }
            """;
 
        var expected = """
            unsafe class C
            {
                private struct S { }
                private delegate*<S, string> f[|i|]eld;
 
                private unsafe delegate*<S, string> Field
                {
                    get
                    {
                        return field;
                    }
 
                    set
                    {
                        field = value;
                    }
                }
 
                void M()
                {
                    var q = field;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData, CompilerTrait(CompilerFeature.FunctionPointers)]
    public async Task FunctionPointerWithPrivateTypeReturnValue(TestHost host)
    {
        var text = """
            unsafe class C
            {
                private struct S { }
                private delegate*<string, S> f[|i|]eld;
 
                void M()
                {
                    var q = field;
                }
            }
            """;
 
        var expected = """
            unsafe class C
            {
                private struct S { }
                private delegate*<string, S> f[|i|]eld;
 
                private unsafe delegate*<string, S> Field
                {
                    get
                    {
                        return field;
                    }
 
                    set
                    {
                        field = value;
                    }
                }
 
                void M()
                {
                    var q = field;
                }
            }
            """;
        await TestAllOptionsOffAsync(host, text, expected, index: 1);
    }
 
    [Theory, CombinatorialData, WorkItem("https://github.com/dotnet/roslyn/issues/75210")]
    public async Task PrimaryConstructor(TestHost host, bool andUseProperty)
    {
        await TestAllOptionsOffAsync(host, """
            public class C(object o)
            {
                public readonly int [|A|] = 1;
            }
            """, """
            public class C(object o)
            {
                private readonly int a = 1;
 
                public int A
                {
                    get
                    {
                        return a;
                    }
                }
            }
            """,
            index: andUseProperty ? 0 : 1);
    }
}