|
// 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;
using Microsoft.CodeAnalysis.CSharp.ConvertTypeOfToNameOf;
using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
using Microsoft.CodeAnalysis.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.ConvertTypeOfToNameOf;
using VerifyCS = CSharpCodeFixVerifier<CSharpConvertTypeOfToNameOfDiagnosticAnalyzer,
CSharpConvertTypeOfToNameOfCodeFixProvider>;
[Trait(Traits.Feature, Traits.Features.ConvertTypeOfToNameOf)]
public partial class ConvertTypeOfToNameOfTests
{
[Fact]
public async Task BasicType()
{
var text = """
class Test
{
void Method()
{
var typeName = [|typeof(Test).Name|];
}
}
""";
var expected = """
class Test
{
void Method()
{
var typeName = nameof(Test);
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task ClassLibraryType()
{
var text = """
class Test
{
void Method()
{
var typeName = [|typeof(System.String).Name|];
}
}
""";
var expected = """
class Test
{
void Method()
{
var typeName = nameof(System.String);
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task ClassLibraryTypeWithUsing()
{
var text = """
using System;
class Test
{
void Method()
{
var typeName = [|typeof(String).Name|];
}
}
""";
var expected = """
using System;
class Test
{
void Method()
{
var typeName = nameof(String);
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task NestedCall()
{
var text = """
using System;
class Test
{
void Method()
{
var typeName = Foo([|typeof(System.String).Name|]);
}
int Foo(String typeName) {
return 0;
}
}
""";
var expected = """
using System;
class Test
{
void Method()
{
var typeName = Foo(nameof(String));
}
int Foo(String typeName) {
return 0;
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task NotOnVariableContainingType()
{
var text = """
using System;
class Test
{
void Method()
{
var typeVar = typeof(String);
var typeName = typeVar.Name;
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, text);
}
[Fact]
public async Task PrimitiveType()
{
var text = """
class Test
{
void Method()
{
var typeName = [|typeof(int).Name|];
}
}
""";
var expected = """
class Test
{
void Method()
{
var typeName = nameof(System.Int32);
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task PrimitiveTypeWithUsing()
{
var text = """
using System;
class Test
{
void Method()
{
var typeName = [|typeof(int).Name|];
}
}
""";
var expected = """
using System;
class Test
{
void Method()
{
var typeName = nameof(Int32);
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact]
public async Task NotOnGenericType()
{
var text = """
class Test<T>
{
void Method()
{
var typeName = typeof(T).Name;
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, text);
}
[Fact]
public async Task NotOnSimilarStatements()
{
var text = """
class Test
{
void Method()
{
var typeName1 = typeof(Test);
var typeName2 = typeof(Test).ToString();
var typeName3 = typeof(Test).FullName;
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, text);
}
[Fact]
public async Task NotInGenericType()
{
var text = """
class Test
{
class Goo<T>
{
void M()
{
_ = typeof(Goo<int>).Name;
}
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, text);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47129")]
public async Task NestedInGenericType()
{
var text = """
class Test
{
class Goo<T>
{
class Bar
{
void M()
{
_ = [|typeof(Bar).Name|];
}
}
}
}
""";
var expected = """
class Test
{
class Goo<T>
{
class Bar
{
void M()
{
_ = nameof(Bar);
}
}
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47129")]
public async Task NestedInGenericType2()
{
var text = """
using System;
using System.Collections.Generic;
class Test
{
public void M()
{
Console.WriteLine([|typeof(List<int>.Enumerator).Name|]);
}
}
""";
var expected = """
using System;
using System.Collections.Generic;
class Test
{
public void M()
{
Console.WriteLine(nameof(List<Int32>.Enumerator));
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, expected);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/54233")]
public async Task NotOnVoid()
{
var text = """
class C
{
void M()
{
var x = typeof(void).Name;
}
}
""";
await VerifyCS.VerifyCodeFixAsync(text, text);
}
[Fact, WorkItem("https://github.com/dotnet/roslyn/issues/47128")]
public async Task TestNint()
{
await new VerifyCS.Test
{
TestCode = """
using System;
class C
{
void M()
{
Console.WriteLine([|typeof(nint).Name|]);
}
}
""",
FixedCode = """
using System;
class C
{
void M()
{
Console.WriteLine(nameof(IntPtr));
}
}
""",
LanguageVersion = LanguageVersion.CSharp10,
}.RunAsync();
}
}
|