File: src\Analyzers\CSharp\Tests\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionFixAllTests.cs
Web Access
Project: src\src\CodeStyle\CSharp\Tests\Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests.csproj (Microsoft.CodeAnalysis.CSharp.CodeStyle.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.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 class ConvertSwitchStatementToExpressionFixAllTests
{
    [Fact]
    public async Task TestNested_01()
    {
        await 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 async Task TestNested_02()
    {
        var input = """
            class Program
            {
                System.Func<int> M(int i, int j)
                {
                    [|switch|] (i)
                    {
                        // 1
                        default: // 2
                            return () =>
                            {
                                [|switch|] (j)
                                {
                                    default:
                                        return 3;
                                }
                            };
                    }
                }
            }
            """;
        var expected = """
            class Program
            {
                System.Func<int> M(int i, int j)
                {
                    return i switch
                    {
                        // 1
                        // 2
                        _ => () =>
                                        {
                                            return j switch
                                            {
                                                _ => 3,
                                            };
                                        }
 
                        ,
                    };
                }
            }
            """;
 
        await new VerifyCS.Test
        {
            TestCode = input,
            FixedCode = expected,
            NumberOfFixAllIterations = 2,
        }.RunAsync();
    }
 
    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/37907")]
    public async Task TestNested_03()
    {
        await 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 async Task TestImplicitConversion()
    {
        await 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,
                    };
                }
            }
            """);
    }
}