From 319a711a8304c58be5fb60c30e343e3d9b6d729b Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 29 Dec 2025 22:26:25 +0000 Subject: [PATCH 1/5] Initial plan From a90aa43af3a21e8bc2c879836f676108312d765e Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 29 Dec 2025 22:35:42 +0000 Subject: [PATCH 2/5] Add unit tests demonstrating whitespace issues in usage analyzers Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com> --- .../GetNamesAnalyzerTests.cs | 62 ++++++++ .../GetValuesAnalyzerTests.cs | 62 ++++++++ .../GetValuesAsUnderlyingTypeAnalyzerTests.cs | 74 ++++++++++ .../ParseAnalyzerTests.cs | 62 ++++++++ .../ToStringAnalyzerTests.cs | 134 ++++++++++++++++++ .../TryParseAnalyzerTests.cs | 99 +++++++++++++ 6 files changed, 493 insertions(+) diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs index 4fa4195..89f1a38 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs @@ -499,4 +499,66 @@ public static class MyEnumExtensions {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; + + [Fact] + public async Task GetNamesAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG008:Enum.GetNames(typeof(MyEnum))|}); + } + + private void SomeMethod(string[] names) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.GetNames()); + } + + private void SomeMethod(string[] names) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task GetNamesWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var names = {|NEEG008:Enum.GetNames(typeof(MyEnum))|}; + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var names = MyEnumExtensions.GetNames(); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } } diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs index 6510dc1..ece75d3 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAnalyzerTests.cs @@ -534,4 +534,66 @@ public static class MyEnumExtensions {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; + + [Fact] + public async Task GetValuesAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG009:Enum.GetValues(typeof(MyEnum))|}); + } + + private void SomeMethod(MyEnum[] values) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.GetValues()); + } + + private void SomeMethod(MyEnum[] values) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task GetValuesWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var values = {|NEEG009:Enum.GetValues(typeof(MyEnum))|}; + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var values = MyEnumExtensions.GetValues(); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } } diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs index b531ce5..ad5205d 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/GetValuesAsUnderlyingTypeAnalyzerTests.cs @@ -486,4 +486,78 @@ public static class MyEnumExtensions {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; + + private static Task VerifyCodeFixWithNet6AssembliesAsync(string source, string fixedSource) + { + var test = new Test + { + TestCode = source, + FixedCode = fixedSource, + ReferenceAssemblies = ReferenceAssemblies.Net.Net60, + }; + + return test.RunAsync(CancellationToken.None); + } + + [Fact] + public async Task GetValuesAsUnderlyingTypeAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG010:Enum.GetValuesAsUnderlyingType(typeof(MyEnum))|}); + } + + private void SomeMethod(int[] values) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.GetValuesAsUnderlyingType()); + } + + private void SomeMethod(int[] values) { } + } + """); + await VerifyCodeFixWithNet6AssembliesAsync(test, fix); + } + + [Fact] + public async Task GetValuesAsUnderlyingTypeWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var values = {|NEEG010:Enum.GetValuesAsUnderlyingType()|}; + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var values = MyEnumExtensions.GetValuesAsUnderlyingType(); + } + } + """); + await VerifyCodeFixWithNet6AssembliesAsync(test, fix); + } } diff --git a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs index a5d8908..799a4ca 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs @@ -704,4 +704,66 @@ public static class MyEnumExtensions {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; + + [Fact] + public async Task ParseAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG002:Enum.Parse(typeof(MyEnum), "First")|}); + } + + private void SomeMethod(MyEnum value) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.Parse("First")); + } + + private void SomeMethod(MyEnum value) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task ParseWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = {|NEEG002:Enum.Parse(typeof(MyEnum), "First")|}; + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = MyEnumExtensions.Parse("First"); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } } diff --git a/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs index 7226111..d639e65 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/ToStringAnalyzerTests.cs @@ -807,6 +807,140 @@ public void TestMethod() await VerifyAnalyzerAsync(test, EnableState.Disabled); } + + [Fact] + public async Task ToStringInConsoleWriteLineShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + System.Console.WriteLine(value.{|NEEG004:ToString|}()); + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + System.Console.WriteLine(value.ToStringFast()); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task ToStringAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + SomeMethod(value.{|NEEG004:ToString|}()); + } + + private void SomeMethod(string s) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + SomeMethod(value.ToStringFast()); + } + + private void SomeMethod(string s) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task ToStringWithMultipleArgumentsShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value1 = TestEnum.First; + var value2 = TestEnum.Second; + SomeMethod(value1.{|NEEG004:ToString|}(), value2.{|NEEG004:ToString|}()); + } + + private void SomeMethod(string s1, string s2) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value1 = TestEnum.First; + var value2 = TestEnum.Second; + SomeMethod(value1.ToStringFast(), value2.ToStringFast()); + } + + private void SomeMethod(string s1, string s2) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task ToStringWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + System.Console.WriteLine(value.{|NEEG004:ToString|}()); + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + var value = TestEnum.First; + System.Console.WriteLine(value.ToStringFast()); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } private static string GetTestCodeWithExternalEnum(string testCode) => $$""" using System; diff --git a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs index a1288e1..2ef650e 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs @@ -744,4 +744,103 @@ public static bool TryParse(ReadOnlySpan name, out MyEnum value, bool igno {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; + + [Fact] + public async Task TryParseInIfStatementShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + if ({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) + System.Console.WriteLine("Parsed"); + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + if (MyEnumExtensions.TryParse("First", out object result)) + System.Console.WriteLine("Parsed"); + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task TryParseAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}); + } + + private void SomeMethod(bool b) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.TryParse("First", out object result)); + } + + private void SomeMethod(bool b) { } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task TryParseWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + if ({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) + { + System.Console.WriteLine("Parsed"); + } + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + if (MyEnumExtensions.TryParse("First", out object result)) + { + System.Console.WriteLine("Parsed"); + } + } + } + """); + await Verifier.VerifyCodeFixAsync(test, fix); + } } From 943a42a625aa407b41af9e66d531d506f2175700 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 29 Dec 2025 22:43:54 +0000 Subject: [PATCH 3/5] Fix diagnostic IDs in Parse and TryParse whitespace tests Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com> --- .../NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs | 4 ++-- .../TryParseAnalyzerTests.cs | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs index 799a4ca..6e8099b 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/ParseAnalyzerTests.cs @@ -715,7 +715,7 @@ public class TestClass { public void TestMethod() { - SomeMethod({|NEEG002:Enum.Parse(typeof(MyEnum), "First")|}); + SomeMethod({|NEEG007:Enum.Parse(typeof(MyEnum), "First")|}); } private void SomeMethod(MyEnum value) { } @@ -748,7 +748,7 @@ public class TestClass { public void TestMethod() { - var value = {|NEEG002:Enum.Parse(typeof(MyEnum), "First")|}; + var value = {|NEEG007:Enum.Parse(typeof(MyEnum), "First")|}; } } """); diff --git a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs index 2ef650e..6ae2326 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/TryParseAnalyzerTests.cs @@ -755,7 +755,7 @@ public class TestClass { public void TestMethod() { - if ({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) + if ({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) System.Console.WriteLine("Parsed"); } } @@ -786,7 +786,7 @@ public class TestClass { public void TestMethod() { - SomeMethod({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}); + SomeMethod({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|}); } private void SomeMethod(bool b) { } @@ -819,7 +819,7 @@ public class TestClass { public void TestMethod() { - if ({|NEEG003:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) + if ({|NEEG011:Enum.TryParse(typeof(MyEnum), "First", out object result)|}) { System.Console.WriteLine("Parsed"); } From e07a17c49577577bb94b5bafc54a9288d373ca01 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Mon, 29 Dec 2025 22:46:18 +0000 Subject: [PATCH 4/5] Attempt to fix GetNames trivia handling with explicit SyntaxFactory usage Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com> --- .../UsageAnalyzers/GetNamesCodeFixProvider.cs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs index 3b28b2e..3ac31b3 100644 --- a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs +++ b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs @@ -3,6 +3,7 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeFixes; +using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Editing; using Microsoft.CodeAnalysis.Simplification; @@ -46,9 +47,11 @@ protected override Task FixWithEditor(DocumentEditor editor, Diagnostic diagnost // Create new invocation: ExtensionsClass.GetNames() var generator = editor.Generator; - var newInvocation = generator.InvocationExpression( - generator.MemberAccessExpression(generator.TypeExpression(extensionTypeSymbol), "GetNames")) - .WithTriviaFrom(invocation) + var memberAccess = (MemberAccessExpressionSyntax)generator.MemberAccessExpression( + generator.TypeExpression(extensionTypeSymbol), "GetNames"); + var newInvocation = SyntaxFactory.InvocationExpression(memberAccess) + .WithLeadingTrivia(invocation.GetLeadingTrivia()) + .WithTrailingTrivia(invocation.GetTrailingTrivia()) .WithAdditionalAnnotations(Simplifier.AddImportsAnnotation, Simplifier.Annotation); editor.ReplaceNode(invocation, newInvocation); From 0875df16999e4bc3c32015a171b4c29e9370c20d Mon Sep 17 00:00:00 2001 From: Andrew Lock Date: Tue, 6 Jan 2026 08:33:35 +0000 Subject: [PATCH 5/5] wip --- .../UsageAnalyzers/GetNamesCodeFixProvider.cs | 8 +- .../GetNamesAnalyzerTests.cs | 124 +++++++++--------- 2 files changed, 65 insertions(+), 67 deletions(-) diff --git a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs index 3ac31b3..414ea3d 100644 --- a/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs +++ b/src/NetEscapades.EnumGenerators.Generators/Diagnostics/UsageAnalyzers/GetNamesCodeFixProvider.cs @@ -47,11 +47,9 @@ protected override Task FixWithEditor(DocumentEditor editor, Diagnostic diagnost // Create new invocation: ExtensionsClass.GetNames() var generator = editor.Generator; - var memberAccess = (MemberAccessExpressionSyntax)generator.MemberAccessExpression( - generator.TypeExpression(extensionTypeSymbol), "GetNames"); - var newInvocation = SyntaxFactory.InvocationExpression(memberAccess) - .WithLeadingTrivia(invocation.GetLeadingTrivia()) - .WithTrailingTrivia(invocation.GetTrailingTrivia()) + var newInvocation = generator.InvocationExpression( + generator.MemberAccessExpression(generator.TypeExpression(extensionTypeSymbol), "GetNames")) + .WithTriviaFrom(invocation) .WithAdditionalAnnotations(Simplifier.AddImportsAnnotation, Simplifier.Annotation); editor.ReplaceNode(invocation, newInvocation); diff --git a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs index 89f1a38..aa3322d 100644 --- a/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs +++ b/tests/NetEscapades.EnumGenerators.Tests/GetNamesAnalyzerTests.cs @@ -428,6 +428,68 @@ public void TestMethod() await VerifyAnalyzerAsync(test, EnableState.Disabled); } + [Fact] + public async Task GetNamesAsMethodArgumentShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod({|NEEG008:Enum.GetNames(typeof(MyEnum))|}); + } + + private void SomeMethod(string[] names) { } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + SomeMethod(MyEnumExtensions.GetNames()); + } + + private void SomeMethod(string[] names) { } + } + """); + await VerifyCodeFixAsync(test, fix); + } + + [Fact] + public async Task GetNamesWithExtraWhitespaceShouldPreserveWhitespace() + { + var test = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + {|NEEG008:Enum.GetNames(typeof(MyEnum))|}; + } + } + """); + + var fix = GetTestCode( + /* lang=c# */ + """ + public class TestClass + { + public void TestMethod() + { + MyEnumExtensions.GetNames(); + } + } + """); + await VerifyCodeFixAsync(test, fix); + } + private static string GetTestCodeWithExternalEnum(string testCode) => $$""" using System; @@ -499,66 +561,4 @@ public static class MyEnumExtensions {{TestHelpers.LoadEmbeddedAttribute()}} {{TestHelpers.LoadEmbeddedMetadataSource()}} """; - - [Fact] - public async Task GetNamesAsMethodArgumentShouldPreserveWhitespace() - { - var test = GetTestCode( - /* lang=c# */ - """ - public class TestClass - { - public void TestMethod() - { - SomeMethod({|NEEG008:Enum.GetNames(typeof(MyEnum))|}); - } - - private void SomeMethod(string[] names) { } - } - """); - - var fix = GetTestCode( - /* lang=c# */ - """ - public class TestClass - { - public void TestMethod() - { - SomeMethod(MyEnumExtensions.GetNames()); - } - - private void SomeMethod(string[] names) { } - } - """); - await Verifier.VerifyCodeFixAsync(test, fix); - } - - [Fact] - public async Task GetNamesWithExtraWhitespaceShouldPreserveWhitespace() - { - var test = GetTestCode( - /* lang=c# */ - """ - public class TestClass - { - public void TestMethod() - { - var names = {|NEEG008:Enum.GetNames(typeof(MyEnum))|}; - } - } - """); - - var fix = GetTestCode( - /* lang=c# */ - """ - public class TestClass - { - public void TestMethod() - { - var names = MyEnumExtensions.GetNames(); - } - } - """); - await Verifier.VerifyCodeFixAsync(test, fix); - } }