src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionFixAllTests.cs - main - githubmirror/roslyn

src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionFixAllTests.cs
322 строки10 KB
Cyrus Najmabadi
Make tests non-async
08 июл 2025, 01:59
08 июл 2025, 01:59c0736fd
// 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.CSharp.ConvertSwitchStatementToExpression;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertSwitchStatementToExpression;

using VerifyCS = CSharpCodeFixVerifier<
    ConvertSwitchStatementToExpressionDiagnosticAnalyzer,
    ConvertSwitchStatementToExpressionCodeFixProvider>;

[Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
public sealed class ConvertSwitchStatementToExpressionFixAllTests
{
    [Fact]
    public Task TestNested_01()
        => VerifyCS.VerifyCodeFixAsync(
            """
            class Program
            {
                int M(int i, int j)
                {
                    int r;
                    [|switch|] (i)
                    {
                        case 1:
                            r = 1;
                            break;
                        case 2:
                            r = 2;
                            break;
                        case 3:
                            r = 3;
                            break;
                        default:
                            r = 4;
                            break;
                    }
                    int x, y;
                    switch (i)
                    {
                        case 1:
                            x = 1;
                            y = 1;
                            break;
                        case 2:
                            x = 1;
                            y = 1;
                            break;
                        case 3:
                            x = 1;
                            y = 1;
                            break;
                        default:
                            x = 1;
                            y = 1;
                            break;
                    }
                    [|switch|] (i)
                    {
                        default:
                            throw null;
                        case 1:
                            [|switch|] (j)
                            {
                                case 10:
                                    return 10;
                                case 20:
                                    return 20;
                                case 30:
                                    return 30;
                            }
                            return 0;
                        case 2:
                            [|switch|] (j)
                            {
                                case 10:
                                    return 10;
                                case 20:
                                    return 20;
                                case 30:
                                    return 30;
                                case var _:
                                    return 0;
                            }
                        case 3:
                            [|switch|] (j)
                            {
                                case 10:
                                    return 10;
                                case 20:
                                    return 20;
                                case 30:
                                    return 30;
                                case var v:
                                    return 0;
                            }
                    }
                }
            }
            """,
            """
            class Program
            {
                int M(int i, int j)
                {
                    var r = i switch
                    {
                        1 => 1,
                        2 => 2,
                        3 => 3,
                        _ => 4,
                    };
                    int x, y;
                    switch (i)
                    {
                        case 1:
                            x = 1;
                            y = 1;
                            break;
                        case 2:
                            x = 1;
                            y = 1;
                            break;
                        case 3:
                            x = 1;
                            y = 1;
                            break;
                        default:
                            x = 1;
                            y = 1;
                            break;
                    }
                    return i switch
                    {
                        1 => j switch
                        {
                            10 => 10,
                            20 => 20,
                            30 => 30,
                            _ => 0,
                        },
                        2 => j switch
                        {
                            10 => 10,
                            20 => 20,
                            30 => 30,
                            var _ => 0,
                        },
                        3 => j switch
                        {
                            10 => 10,
                            20 => 20,
                            30 => 30,
                            var v => 0,
                        },
                        _ => throw null,
                    };
                }
            }
            """);

    [Fact]
    public Task TestNested_02()
        => new VerifyCS.Test
        {
            TestCode = """
            class Program
            {
                System.Func<int> M(int i, int j)
                {
                    [|switch|] (i)
                    {
                        // 1
                        default: // 2
                            return () =>
                            {
                                [|switch|] (j)
                                {
                                    default:
                                        return 3;
                                }
                            };
                    }
                }
            }
            """,
            FixedCode = """
            class Program
            {
                System.Func<int> M(int i, int j)
                {
                    return i switch
                    {
                        // 1
                        // 2
                        _ => () =>
                                        {
                                            return j switch
                                            {
                                                _ => 3,
                                            };
                                        }

                        ,
                    };
                }
            }
            """,
            NumberOfFixAllIterations = 2,
        }.RunAsync();

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37907")]
    public Task TestNested_03()
        => VerifyCS.VerifyCodeFixAsync(
            """
            using System;

            class Program
            {
                public static void Main() { }
                public DayOfWeek StatusValue() => DayOfWeek.Monday;
                public short Value => 0;
                public bool ValueBoolean()
                {
                    bool value;
                    [|switch|] (StatusValue())
                    {
                        case DayOfWeek.Monday:
                            [|switch|] (Value)
                            {
                                case 0:
                                    value = false;
                                    break;
                                case 1:
                                    value = true;
                                    break;
                                default:
                                    throw new Exception();
                            }
                            break;
                        default:
                            throw new Exception();
                    }
                    return value;
                }
            }
            """,
            """
            using System;

            class Program
            {
                public static void Main() { }
                public DayOfWeek StatusValue() => DayOfWeek.Monday;
                public short Value => 0;
                public bool ValueBoolean()
                {
                    var value = StatusValue() switch
                    {
                        DayOfWeek.Monday => Value switch
                        {
                            0 => false,
                            1 => true,
                            _ => throw new Exception(),
                        },
                        _ => throw new Exception(),
                    };
                    return value;
                }
            }
            """);
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/44572")]
    public Task TestImplicitConversion()
        => VerifyCS.VerifyCodeFixAsync(
            """
            using System;

            class C
            {
                public C(String s) => _s = s;
                private readonly String _s;
                public static implicit operator String(C value) => value._s;
                public static implicit operator C(String value) => new C(value);
                
                public bool method(C c)
                {
                    [|switch|] (c)
                    {
                        case "A": return true;
                        default: return false;
                    }
                }
            }
            """,
            """
            using System;

            class C
            {
                public C(String s) => _s = s;
                private readonly String _s;
                public static implicit operator String(C value) => value._s;
                public static implicit operator C(String value) => new C(value);
                
                public bool method(C c)
                {
                    return (string)c switch
                    {
                        "A" => true,
                        _ => false,
                    };
                }
            }
            """);
}