Merge pull request #46599 from sharwell/finish-convert

Finish 'Generate Equals' conversion to new test library

eng/Versions.props

@@ -30,7 +30,7 @@
     <RoslynDiagnosticsNugetPackageVersion>3.3.0-beta1.20352.4</RoslynDiagnosticsNugetPackageVersion>
     <MicrosoftCodeAnalysisNetAnalyzersVersion>3.3.0-beta1.20352.4</MicrosoftCodeAnalysisNetAnalyzersVersion>
     <CodeStyleLayerCodeAnalysisVersion>3.6.0-2.final</CodeStyleLayerCodeAnalysisVersion>
-    <MicrosoftCodeAnalysisTestingVersion>1.0.1-beta1.20378.2</MicrosoftCodeAnalysisTestingVersion>
+    <MicrosoftCodeAnalysisTestingVersion>1.0.1-beta1.20407.3</MicrosoftCodeAnalysisTestingVersion>
     <CodeStyleAnalyzerVersion>3.7.0-3.20271.4</CodeStyleAnalyzerVersion>
     <VisualStudioEditorPackagesVersion>16.4.248</VisualStudioEditorPackagesVersion>
     <ILToolsPackageVersion>5.0.0-alpha1.19409.1</ILToolsPackageVersion>
@@ -60,11 +60,13 @@
     -->
     <MicrosoftCodeAnalysisAnalyzersVersion>3.0.0</MicrosoftCodeAnalysisAnalyzersVersion>
     <MicrosoftCodeAnalysisBuildTasksVersion>2.0.0-rc2-61102-09</MicrosoftCodeAnalysisBuildTasksVersion>
+    <MicrosoftCodeAnalysisCSharpAnalyzerTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisCSharpAnalyzerTestingXUnitVersion>
     <MicrosoftCodeAnalysisCSharpCodeFixTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisCSharpCodeFixTestingXUnitVersion>
     <MicrosoftCodeAnalysisCSharpCodeRefactoringTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisCSharpCodeRefactoringTestingXUnitVersion>
     <MicrosoftCodeAnalysisCSharpCodeStyleVersion>$(CodeStyleAnalyzerVersion)</MicrosoftCodeAnalysisCSharpCodeStyleVersion>
     <MicrosoftCodeAnalysisElfieVersion>0.10.6</MicrosoftCodeAnalysisElfieVersion>
     <MicrosoftCodeAnalysisTestResourcesProprietaryVersion>2.0.41</MicrosoftCodeAnalysisTestResourcesProprietaryVersion>
+    <MicrosoftCodeAnalysisVisualBasicAnalyzerTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisVisualBasicAnalyzerTestingXUnitVersion>
     <MicrosoftCodeAnalysisVisualBasicCodeFixTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisVisualBasicCodeFixTestingXUnitVersion>
     <MicrosoftCodeAnalysisVisualBasicCodeRefactoringTestingXUnitVersion>$(MicrosoftCodeAnalysisTestingVersion)</MicrosoftCodeAnalysisVisualBasicCodeRefactoringTestingXUnitVersion>
     <MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>$(CodeStyleAnalyzerVersion)</MicrosoftCodeAnalysisVisualBasicCodeStyleVersion>

src/EditorFeatures/CSharpTest/GenerateComparisonOperators/GenerateComparisonOperatorsTests.cs

@@ -2,69 +2,23 @@
 // 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.Collections.Generic;
 using System.Threading.Tasks;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
-using Microsoft.CodeAnalysis.GenerateComparisonOperators;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.CodeAnalysis.Testing;
 using Xunit;
+using VerifyCS = Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.CSharpCodeRefactoringVerifier<
+    Microsoft.CodeAnalysis.GenerateComparisonOperators.GenerateComparisonOperatorsCodeRefactoringProvider>;
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.GenerateComparisonOperators
 {
-    using static Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions.AbstractCodeActionOrUserDiagnosticTest;
-    using VerifyCS = CSharpCodeRefactoringVerifier<GenerateComparisonOperatorsCodeRefactoringProvider>;
-
     [UseExportProvider]
     public class GenerateComparisonOperatorsTests
     {
-        private static Task TestInRegularAndScript1Async(
-            string initialMarkup,
-            string expectedMarkup,
-            int index = 0,
-            TestParameters? parameters = null,
-            List<DiagnosticResult> fixedExpectedDiagnostics = null)
-        {
-            return TestInRegularAndScript1Async(
-                new[] { initialMarkup }, new[] { expectedMarkup }, index, parameters, fixedExpectedDiagnostics);
-        }
-
-        private static async Task TestInRegularAndScript1Async(
-            string[] initialMarkup,
-            string[] expectedMarkup,
-            int index = 0,
-            TestParameters? parameters = null,
-            List<DiagnosticResult> fixedExpectedDiagnostics = null)
-        {
-            var test = new VerifyCS.Test
-            {
-                CodeActionIndex = index,
-            };
-
-            foreach (var source in initialMarkup)
-                test.TestState.Sources.Add(source);
-
-            foreach (var source in expectedMarkup)
-                test.FixedState.Sources.Add(source);
-
-            if (parameters?.parseOptions != null)
-                test.LanguageVersion = ((CSharpParseOptions)parameters.Value.parseOptions).LanguageVersion;
-
-            if (parameters?.options != null)
-                test.EditorConfig = CodeFixVerifierHelper.GetEditorConfigText(parameters.Value.options);
-
-            foreach (var diagnostic in fixedExpectedDiagnostics ?? new List<DiagnosticResult>())
-                test.FixedState.ExpectedDiagnostics.Add(diagnostic);
-
-            await test.RunAsync();
-        }
-
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestClass()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -138,7 +92,7 @@ class C : IComparable<C>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestExplicitImpl()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -178,7 +132,7 @@ class C : IComparable<C>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestOnInterface()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -218,7 +172,7 @@ class C : IComparable<C>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestAtEndOfInterface()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -258,7 +212,7 @@ class C : IComparable<C>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestInBody()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -308,11 +262,7 @@ class C : {|CS0535:IComparable<C>|}
 [||]
 }";
 
-            await new VerifyCS.Test
-            {
-                TestCode = code,
-                FixedCode = code,
-            }.RunAsync();
+            await VerifyCS.VerifyRefactoringAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
@@ -328,11 +278,7 @@ class C : IComparable<{|CS0246:Goo|}>
 [||]
 }";
 
-            await new VerifyCS.Test
-            {
-                TestCode = code,
-                FixedCode = code,
-            }.RunAsync();
+            await VerifyCS.VerifyRefactoringAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
@@ -369,17 +315,13 @@ class C : IComparable<C>
 [||]
 }";
 
-            await new VerifyCS.Test
-            {
-                TestCode = code,
-                FixedCode = code,
-            }.RunAsync();
+            await VerifyCS.VerifyRefactoringAsync(code, code);
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestWithExistingOperator()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 
@@ -426,7 +368,7 @@ class C : IComparable<C>
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestMultipleInterfaces()
         {
-            await TestInRegularAndScript1Async(
+            var code =
 @"
 using System;
 
@@ -436,41 +378,58 @@ class C : IComparable<C>, IComparable<int>
     public int CompareTo(int c) => 0;
 
 [||]
-}",
-@"
+}";
+            string GetFixedCode(string type) =>
+$@"
 using System;
 
 class C : IComparable<C>, IComparable<int>
-{
+{{
     public int CompareTo(C c) => 0;
     public int CompareTo(int c) => 0;
 
-    public static bool operator <(C left, int right)
-    {
+    public static bool operator <(C left, {type} right)
+    {{
         return left.CompareTo(right) < 0;
-    }
+    }}
 
-    public static bool operator >(C left, int right)
-    {
+    public static bool operator >(C left, {type} right)
+    {{
         return left.CompareTo(right) > 0;
-    }
+    }}
 
-    public static bool operator <=(C left, int right)
-    {
+    public static bool operator <=(C left, {type} right)
+    {{
         return left.CompareTo(right) <= 0;
-    }
+    }}
 
-    public static bool operator >=(C left, int right)
-    {
+    public static bool operator >=(C left, {type} right)
+    {{
         return left.CompareTo(right) >= 0;
-    }
-}", index: 1);
+    }}
+}}";
+
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = GetFixedCode("C"),
+                CodeActionIndex = 0,
+                CodeActionEquivalenceKey = "Generate_for_0_C",
+            }.RunAsync();
+
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = GetFixedCode("int"),
+                CodeActionIndex = 1,
+                CodeActionEquivalenceKey = "Generate_for_0_int",
+            }.RunAsync();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateComparisonOperators)]
         public async Task TestInInterfaceWithDefaultImpl()
         {
-            await TestInRegularAndScript1Async(
+            await VerifyCS.VerifyRefactoringAsync(
 @"
 using System;
 

src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs

@@ -98,7 +98,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 var missingType = missingComparableTypes[0];
                 context.RegisterRefactoring(new MyCodeAction(
                     FeaturesResources.Generate_comparison_operators,
-                    c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c)));
+                    c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c),
+                    nameof(FeaturesResources.Generate_comparison_operators)));
                 return;
             }
 
@@ -110,7 +111,8 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 var displayString = typeArg.ToMinimalDisplayString(semanticModel, textSpan.Start);
                 nestedActions.Add(new MyCodeAction(
                     string.Format(FeaturesResources.Generate_for_0, displayString),
-                    c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c)));
+                    c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c),
+                    nameof(FeaturesResources.Generate_for_0) + "_" + displayString));
             }
 
             context.RegisterRefactoring(new CodeAction.CodeActionWithNestedActions(
@@ -269,8 +271,8 @@ private static string GetOperatorName(CodeGenerationOperatorKind kind)
 
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(title, createChangedDocument)
+            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument, string equivalenceKey)
+                : base(title, createChangedDocument, equivalenceKey)
             {
             }
         }

src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndGetHashCodeAction.cs

@@ -54,6 +54,8 @@ private partial class GenerateEqualsAndGetHashCodeAction : CodeAction
                 _generateOperators = generateOperators;
             }
 
+            public override string EquivalenceKey => Title;
+
             protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
             {
                 using var _ = ArrayBuilder<IMethodSymbol>.GetInstance(out var methods);

src/Features/Core/Portable/GenerateEqualsAndGetHashCodeFromMembers/GenerateEqualsAndHashWithDialogCodeAction.cs

@@ -51,6 +51,8 @@ private class GenerateEqualsAndGetHashCodeWithDialogCodeAction : CodeActionWithO
                 _generateGetHashCode = generateGetHashCode;
             }
 
+            public override string EquivalenceKey => Title;
+
             public override object GetOptions(CancellationToken cancellationToken)
             {
                 var service = _service._pickMembersService_forTestingPurposes ?? _document.Project.Solution.Workspace.Services.GetRequiredService<IPickMembersService>();

src/Workspaces/CoreTestUtilities/Roslyn.Services.UnitTests.Utilities.csproj

@@ -23,8 +23,10 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CSharp" Version="$(MicrosoftCSharpVersion)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.XUnit" Version="$(MicrosoftCodeAnalysisCSharpAnalyzerTestingXUnitVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisCSharpCodeFixTestingXUnitVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeRefactoring.Testing.XUnit" Version="$(MicrosoftCodeAnalysisCSharpCodeRefactoringTestingXUnitVersion)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.Analyzer.Testing.XUnit" Version="$(MicrosoftCodeAnalysisVisualBasicAnalyzerTestingXUnitVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.CodeFix.Testing.XUnit" Version="$(MicrosoftCodeAnalysisVisualBasicCodeFixTestingXUnitVersion)" />
     <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic.CodeRefactoring.Testing.XUnit" Version="$(MicrosoftCodeAnalysisVisualBasicCodeRefactoringTestingXUnitVersion)" />
     <PackageReference Include="Microsoft.VisualStudio.Composition" Version="$(MicrosoftVisualStudioCompositionVersion)" />