src/Features/CSharpTest/SpellCheck/SpellCheckTests.cs - main - githubmirror/roslyn

src/Features/CSharpTest/SpellCheck/SpellCheckTests.cs
617 строк15 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.

#nullable disable

using System;
using System.Collections.Immutable;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CSharp.SpellCheck;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using Xunit.Abstractions;

namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.SpellCheck;

[Trait(Traits.Feature, Traits.Features.CodeActionsSpellcheck)]
public sealed class SpellCheckTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest_NoEditor
{
    public SpellCheckTests(ITestOutputHelper logger)
      : base(logger)
    {
    }

    internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
        => (null, new CSharpSpellCheckCodeFixProvider());

    protected override ImmutableArray<CodeAction> MassageActions(ImmutableArray<CodeAction> actions)
        => FlattenActions(actions);

    [Fact]
    public Task TestNoSpellcheckForIfOnly2Characters()
        => TestMissingInRegularAndScriptAsync("""
            class Goo
            {
                void Bar()
                {
                    var a = new [|Fo|]
                }
            }
            """);

    [Fact]
    public Task TestAfterNewExpression()
        => TestExactActionSetOfferedAsync("""
            class Goo
            {
                void Bar()
                {
                    void a = new [|Gooa|].ToString();
                }
            }
            """, [String.Format(FeaturesResources.Change_0_to_1, "Gooa", "Goo")]);

    [Fact]
    public Task TestInLocalType()
        => TestExactActionSetOfferedAsync("""
            class Foo
            {
                void Bar()
                {
                    [|Foa|] a;
                }
            }
            """,
        [
            String.Format(FeaturesResources.Change_0_to_1, "Foa", "Foo"),
            String.Format(FeaturesResources.Change_0_to_1, "Foa", "for")
        ]);

    [Fact]
    public Task TestInFunc()
        => TestExactActionSetOfferedAsync("""
            using System;

            class Goo
            {
                void Bar(Func<[|Goa|]> f)
                {
                }
            }
            """,
            [String.Format(FeaturesResources.Change_0_to_1, "Goa", "Goo")]);

    [Fact]
    public Task TestInExpression()
        => TestExactActionSetOfferedAsync("""
            class Program
            {
                void Main(string[] args)
                {
                    var zzz = 2;
                    var  y = 2 + [|zza|];
                }
            }
            """, [String.Format(FeaturesResources.Change_0_to_1, "zza", "zzz")]);

    [Fact]
    public Task TestInTypeOfIsExpression()
        => TestExactActionSetOfferedAsync("""
            using System;
            public class Class1
            {
                void F()
                {
                    if (x is [|Boolea|]) {}
                }
            }
            """,
        [
            String.Format(FeaturesResources.Change_0_to_1, "Boolea", "Boolean"),
            String.Format(FeaturesResources.Change_0_to_1, "Boolea", "bool")
        ]);

    [Fact]
    public Task TestInvokeCorrectIdentifier()
        => TestInRegularAndScriptAsync("""
            class Program
            {
                void Main(string[] args)
                {
                    var zzz = 2;
                    var y = 2 + [|zza|];
                }
            }
            """, """
            class Program
            {
                void Main(string[] args)
                {
                    var zzz = 2;
                    var y = 2 + zzz;
                }
            }
            """);

    [Fact]
    public Task TestAfterDot()
        => TestInRegularAndScriptAsync("""
            class Program
            {
                static void Main(string[] args)
                {
                    Program.[|Mair|]
                }
            }
            """, """
            class Program
            {
                static void Main(string[] args)
                {
                    Program.Main
                }
            }
            """);

    [Fact]
    public Task TestNotInaccessibleProperty()
        => TestMissingInRegularAndScriptAsync("""
            class Program
            {
                void Main(string[] args)
                {
                    var z = new c().[|membr|]
                }
            }

            class c
            {
                protected int member { get; }
            }
            """);

    [Fact]
    public Task TestGenericName1()
        => TestInRegularAndScriptAsync("""
            class Goo<T>
            {
                private [|Goo2|]<T> x;
            }
            """, """
            class Goo<T>
            {
                private Goo<T> x;
            }
            """);

    [Fact]
    public Task TestGenericName2()
        => TestInRegularAndScriptAsync("""
            class Goo<T>
            {
                private [|Goo2|] x;
            }
            """, """
            class Goo<T>
            {
                private Goo x;
            }
            """);

    [Fact]
    public Task TestQualifiedName1()
        => TestInRegularAndScriptAsync("""
            class Program
            {
               private object x = new [|Goo2|].Bar
            }

            class Goo
            {
                class Bar
                {
                }
            }
            """, """
            class Program
            {
               private object x = new Goo.Bar
            }

            class Goo
            {
                class Bar
                {
                }
            }
            """);

    [Fact]
    public Task TestQualifiedName2()
        => TestInRegularAndScriptAsync("""
            class Program
            {
                private object x = new Goo.[|Ba2|]
            }

            class Goo
            {
                public class Bar
                {
                }
            }
            """, """
            class Program
            {
                private object x = new Goo.Bar
            }

            class Goo
            {
                public class Bar
                {
                }
            }
            """);

    [Fact]
    public Task TestMiddleOfDottedExpression()
        => TestInRegularAndScriptAsync("""
            class Program
            {
                void Main(string[] args)
                {
                    var z = new c().[|membr|].ToString();
                }
            }

            class c
            {
                public int member { get; }
            }
            """, """
            class Program
            {
                void Main(string[] args)
                {
                    var z = new c().member.ToString();
                }
            }

            class c
            {
                public int member { get; }
            }
            """);

    [Fact]
    public Task TestNotForOverloadResolutionFailure()
        => TestMissingInRegularAndScriptAsync("""
            class Program
            {
                void Main(string[] args)
                {
                }

                void Goo()
                {
                    [|Method|]();
                }

                int Method(int argument)
                {
                }
            }
            """);

    [Fact]
    public Task TestHandlePredefinedTypeKeywordCorrectly()
        => TestInRegularAndScriptAsync("""
            using System;
            using System.Collections.Generic;
            using System.Linq;

            class Program
            {
                void Main(string[] args)
                {
                    [|Int3|] i;
                }
            }
            """, """
            using System;
            using System.Collections.Generic;
            using System.Linq;

            class Program
            {
                void Main(string[] args)
                {
                    int i;
                }
            }
            """);

    [Fact]
    public Task TestHandlePredefinedTypeKeywordCorrectly1()
        => TestInRegularAndScriptAsync("""
            using System;
            using System.Collections.Generic;
            using System.Linq;

            class Program
            {
                void Main(string[] args)
                {
                    [|Int3|] i;
                }
            }
            """, """
            using System;
            using System.Collections.Generic;
            using System.Linq;

            class Program
            {
                void Main(string[] args)
                {
                    Int32 i;
                }
            }
            """, index: 1);

    [Fact]
    public Task TestOnGeneric()
        => TestInRegularAndScriptAsync("""
            interface Enumerable<T>
            {
            }

            class C
            {
                void Main(string[] args)
                {
                    [|IEnumerable|]<int> x;
                }
            }
            """, """
            interface Enumerable<T>
            {
            }

            class C
            {
                void Main(string[] args)
                {
                    Enumerable<int> x;
                }
            }
            """);

    [Fact]
    public Task TestTestObjectConstruction()
        => TestInRegularAndScriptAsync(
            """
            class AwesomeClass
            {
                void M()
                {
                    var goo = new [|AwesomeClas()|];
                }
            }
            """,
            """
            class AwesomeClass
            {
                void M()
                {
                    var goo = new AwesomeClass();
                }
            }
            """);

    [Fact]
    public Task TestTestMissingName()
        => TestMissingInRegularAndScriptAsync(
@"[assembly: Microsoft.CodeAnalysis.[||]]");

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/12990")]
    public Task TestTrivia1()
        => TestInRegularAndScriptAsync("""
            using System.Text;
            class C
            {
              void M()
              {
                /*leading*/ [|stringbuilder|] /*trailing*/ sb = null;
              }
            }
            """, """
            using System.Text;
            class C
            {
              void M()
              {
                /*leading*/ StringBuilder /*trailing*/ sb = null;
              }
            }
            """);

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/13345")]
    public Task TestNotMissingOnKeywordWhichIsAlsoASnippet()
        => TestInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    // here 'for' is a keyword and snippet, so we should offer to spell check to it.
                    [|foo|];
                }
            }
            """,
            """
            class C
            {
                void M()
                {
                    // here 'for' is a keyword and snippet, so we should offer to spell check to it.
                    for;
                }
            }
            """);

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/18626")]
    public Task TestForExplicitInterfaceTypeName()
        => TestInRegularAndScriptAsync(
            """
            interface IProjectConfigurationsService
            {
                void Method();
            }

            class Program : IProjectConfigurationsService
            {
                void [|IProjectConfigurationService|].Method()
                {

                }
            }
            """,
            """
            interface IProjectConfigurationsService
            {
                void Method();
            }

            class Program : IProjectConfigurationsService
            {
                void IProjectConfigurationsService.Method()
                {

                }
            }
            """);

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/13345")]
    public Task TestMissingOnKeywordWhichIsOnlyASnippet()
        => TestMissingInRegularAndScriptAsync(
            """
            class C
            {
                void M()
                {
                    // here 'for' is *only* a snippet, and we should not offer to spell check to it.
                    var v = [|goo|];
                }
            }
            """);

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/15733")]
    public Task TestMissingOnVar()
        => TestMissingInRegularAndScriptAsync(
            """
            namespace bar { }

            class C
            {
                void M()
                {
                    var y =
                    [|var|]
                }
            }
            """);

    [Fact]
    public Task TestUnmanagedConstraint()
        => TestInRegularAndScriptAsync(
            """
            class C<T> where T : [|umanaged|]
            {
            }
            """,
            """
            class C<T> where T : unmanaged
            {
            }
            """);

    [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/28244")]
    public Task TestMisspelledConstructor()
        => TestInRegularAndScriptAsync(
            """
            public class SomeClass
            {
                public [|SomeClss|]() { }
            }
            """,
            """
            public class SomeClass
            {
                public SomeClass() { }
            }
            """);

    [Fact]
    public Task TestInExplicitInterfaceImplementation1()
        => TestMissingInRegularAndScriptAsync("""
            using System;

            class Program : IDisposable
            {
                void IDisposable.[|Dspose|]
            }
            """);

    [Fact]
    public Task TestInExplicitInterfaceImplementation2()
        => TestMissingInRegularAndScriptAsync("""
            using System;

            interface IInterface
            {
                void Generic<K, V>();
            }

            class Program : IInterface
            {
                void IInterface.[|Generi|]
            }
            """);

    [Fact]
    public Task TestInExplicitInterfaceImplementation3()
        => TestMissingInRegularAndScriptAsync("""
            using System;

            interface IInterface
            {
                int this[int i] { get; }
            }

            class Program : IInterface
            {
                void IInterface.[|thi|]
            }
            """);

    [Fact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1640728")]
    public Task TestMisspelledWordThatIsAlsoSnippetName()
        => TestInRegularAndScriptAsync(
            """
            public [|interfacce|] IWhatever
            {
            }
            """,
            """
            public interface IWhatever
            {
            }
            """);
}