src/Features/CSharpTest/UseRecursivePatterns/UseRecursivePatternsRefactoringFixAllTests.cs - main - githubmirror/roslyn

src/Features/CSharpTest/UseRecursivePatterns/UseRecursivePatternsRefactoringFixAllTests.cs
689 строк20 KB
Cyrus Najmabadi
Use raw strings in tests
09 июл 2025, 08:52
09 июл 2025, 08:52f265dce
// 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.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeRefactorings;
using Microsoft.CodeAnalysis.CSharp.CodeRefactorings.UseRecursivePatterns;
using Microsoft.CodeAnalysis.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.CodeRefactorings.UseRecursivePatterns;

[Trait(Traits.Feature, Traits.Features.CodeActionsUseRecursivePatterns)]
[Trait(Traits.Feature, Traits.Features.CodeActionsFixAllOccurrences)]
public sealed class UseRecursivePatternsRefactoringFixAllTests : AbstractCSharpCodeActionTest_NoEditor
{
    protected override CodeRefactoringProvider CreateCodeRefactoringProvider(TestWorkspace workspace, TestParameters parameters)
        => new UseRecursivePatternsCodeRefactoringProvider();

    [Fact]
    public Task UseRecursivePatterns_FixAllInDocument()
        => TestInRegularAndScriptAsync("""
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (n == a.b.c.d {|FixAllInDocument:|}&& a.b.c.a == n)
                        {
                        }

                        if (this.P1 < 1 && 2 >= this.P2)
                        {
                        }

                        if (!B1 && B2)
                        {
                        }
                    }
                }

                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """, """
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (a.b.c is { d: n, a: n })
                        {
                        }

                        if (this is { P1: < 1, P2: <= 2 })
                        {
                        }

                        if (this is { B1: false, B2: true })
                        {
                        }
                    }
                }

                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """);

    [Fact]
    public Task UseRecursivePatterns_FixAllInProject()
        => TestInRegularAndScriptAsync("""
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        _ = this switch
                        {
                            { a: var x } {|FixAllInProject:|}when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class E : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """, """
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class E : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """);

    [Fact]
    public Task UseRecursivePatterns_FixAllInSolution()
        => TestInRegularAndScriptAsync("""
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        _ = this switch
                        {
                            { a: var x } {|FixAllInSolution:|}when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class E : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """, """
            <Workspace>
                <Project Language="C#" AssemblyName="Assembly1" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                    <Document>
            namespace NS
            {
                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
                    </Document>
                </Project>
                <Project Language="C#" AssemblyName="Assembly2" CommonReferences="true">
                    <Document>
            namespace NS
            {
                class E : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: { b: n } x } => 0
                        };

                        switch (this)
                        {
                            case { a: { b: n } x }:
                                break;
                        }
                    }
                }
            }
                    </Document>
                </Project>
            </Workspace>
            """);

    [Fact]
    public Task UseRecursivePatterns_FixAllInContainingMember()
        => TestInRegularAndScriptAsync("""
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (n == a.b.c.d {|FixAllInContainingMember:|}&& a.b.c.a == n)
                        {
                        }

                        if (this.P1 < 1 && 2 >= this.P2)
                        {
                        }

                        if (!B1 && B2)
                        {
                        }
                    }
                }

                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """, """
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (a.b.c is { d: n, a: n })
                        {
                        }

                        if (this is { P1: < 1, P2: <= 2 })
                        {
                        }

                        if (this is { B1: false, B2: true })
                        {
                        }
                    }
                }

                class D : C
                {
                    void M2()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """);

    [Fact]
    public Task UseRecursivePatterns_FixAllInContainingType()
        => TestInRegularAndScriptAsync("""
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (n == a.b.c.d {|FixAllInContainingType:|}&& a.b.c.a == n)
                        {
                        }
                    }

                    void M2()
                    {
                        if (this.P1 < 1 && 2 >= this.P2)
                        {
                        }

                        if (!B1 && B2)
                        {
                        }
                    }
                }

                class D : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """, """
            namespace NS
            {
                class C : B
                {
                    void M1()
                    {
                        if (a.b.c is { d: n, a: n })
                        {
                        }
                    }

                    void M2()
                    {
                        if (this is { P1: < 1, P2: <= 2 })
                        {
                        }

                        if (this is { B1: false, B2: true })
                        {
                        }
                    }
                }

                class D : C
                {
                    void M3()
                    {
                        _ = this switch
                        {
                            { a: var x } when x is { b: n } => 0
                        };

                        switch (this)
                        {
                            case { a: var x } when x is { b: n }:
                                break;
                        }
                    }
                }

                class B
                {
                    public const C n = null;
                    public C a, b, c, d;
                    public int P1, P2, P3;
                    public bool B1, B2;
                    public C CP1, CP2;
                    public static C SCP1, SCP2;
                    public static int SP1, SP2;
                    public C m() { return null; }
                }
            }
            """);
}