// 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.CodeFixes.MakeStatementAsynchronous;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Microsoft.CodeAnalysis.Testing;
using Xunit;
 
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.MakeStatementAsynchronous;
 
using VerifyCS = CSharpCodeFixVerifier<
    EmptyDiagnosticAnalyzer,
    CSharpMakeStatementAsynchronousCodeFixProvider>;
 
[Trait(Traits.Feature, Traits.Features.CodeActionsMakeStatementAsynchronous)]
public class CSharpMakeStatementAsynchronousCodeFixTests
{
    [Fact]
    public async Task FixAllForeach()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<int> collection)
                    {
                        foreach (var i in {|CS8414:collection|}) { }
                        foreach (var j in {|CS8414:collection|}) { }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<int> collection)
                    {
                        {|CS4033:await|} foreach (var i in collection) { }
                        {|CS4033:await|} foreach (var j in collection) { }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixAllForeachDeconstruction()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<(int, int)> collection)
                    {
                        foreach (var ({|CS8130:i|}, {|CS8130:j|}) in {|CS8414:collection|}) { }
                        foreach (var ({|CS8130:k|}, {|CS8130:l|}) in {|CS8414:collection|}) { }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<(int, int)> collection)
                    {
                        {|CS4033:await|} foreach (var (i, j) in collection) { }
                        {|CS4033:await|} foreach (var (k, l) in collection) { }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixAllUsingStatement()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        using ({|CS8418:var i = disposable|}) { }
                        using ({|CS8418:var j = disposable|}) { }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS4033:await|} using (var i = disposable) { }
                        {|CS4033:await|} using (var j = disposable) { }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixAllUsingDeclaration()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS8418:using var i = disposable;|}
                        {|CS8418:using var j = disposable;|}
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS4033:await|} using var i = disposable;
                        {|CS4033:await|} using var j = disposable;
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixForeach()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<int> collection)
                    {
                        foreach (var i in {|CS8414:collection|})
                        {
                        }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<int> collection)
                    {
                        {|CS4033:await|} foreach (var i in collection)
                        {
                        }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixForeachDeconstruction()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<(int, int)> collection)
                    {
                        foreach (var ({|CS8130:i|}, {|CS8130:j|}) in {|CS8414:collection|})
                        {
                        }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.Collections.Generic.IAsyncEnumerable<(int, int)> collection)
                    {
                        {|CS4033:await|} foreach (var (i, j) in collection)
                        {
                        }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixUsingStatement()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        using ({|CS8418:var i = disposable|})
                        {
                        }
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS4033:await|} using (var i = disposable)
                        {
                        }
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
 
    [Fact]
    public async Task FixUsingDeclaration()
    {
        await new VerifyCS.Test()
        {
            TestCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS8418:using var i = disposable;|}
                    }
                }
                """,
            FixedCode = """
                class Program
                {
                    void M(System.IAsyncDisposable disposable)
                    {
                        {|CS4033:await|} using var i = disposable;
                    }
                }
                """,
            ReferenceAssemblies = ReferenceAssemblies.Net.Net60
        }.RunAsync();
    }
}