public async Task TestGetFixesAsyncHasNoDuplicateConfigurationActions()
{
var codeFix = new MockFixer();
// Add analyzers with duplicate ID and/or category to get duplicate diagnostics.
var analyzerReference = new MockAnalyzerReference(
codeFix,
ImmutableArray.Create <DiagnosticAnalyzer>(
new MockAnalyzerReference.MockDiagnosticAnalyzer("ID1", "Category1"),
new MockAnalyzerReference.MockDiagnosticAnalyzer("ID1", "Category1"),
new MockAnalyzerReference.MockDiagnosticAnalyzer("ID1", "Category2"),
new MockAnalyzerReference.MockDiagnosticAnalyzer("ID2", "Category2")));
var tuple = ServiceSetup(codeFix, includeConfigurationFixProviders: true);
using var workspace = tuple.workspace;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
// Verify registered configuration code actions do not have duplicates.
var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CodeActionOptions.DefaultProvider, isBlocking : false, CancellationToken.None);
var codeActions = fixCollections.SelectMany(c => c.Fixes.Select(f => f.Action)).ToImmutableArray();
Assert.Equal(7, codeActions.Length);
var uniqueTitles = new HashSet <string>();
foreach (var codeAction in codeActions)
{
Assert.True(codeAction is AbstractConfigurationActionWithNestedActions);
Assert.True(uniqueTitles.Add(codeAction.Title));
}
}
public void TestGetFirstDiagnosticWithFixAsync()
{
var diagnosticService = new DiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var fixers = CreateFixers();
var fixService = new CodeFixService(
diagnosticService, fixers, SpecializedCollections.EmptyEnumerable<Lazy<ISuppressionFixProvider, CodeChangeProviderMetadata>>());
var code = @"
a
";
using (var workspace =
CSharpWorkspaceFactory.CreateWorkspaceFromFile(code))
{
var incrementalAnalzyer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalzyer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
var unused = fixService.GetFirstDiagnosticWithFixAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None).Result;
var fixer1 = fixers.Single().Value as MockFixer;
var fixer2 = reference.Fixer as MockFixer;
// check to make sure both of them are called.
Assert.True(fixer1.Called);
Assert.True(fixer2.Called);
}
}
public async Task TestGetFirstDiagnosticWithFixAsync()
{
var diagnosticService = new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var fixers = CreateFixers();
var code = @"
a
";
using var workspace = TestWorkspace.CreateCSharp(code);
var logger = SpecializedCollections.SingletonEnumerable(new Lazy <IErrorLoggerService>(() => workspace.Services.GetService <IErrorLoggerService>()));
var fixService = new CodeFixService(
workspace.ExportProvider.GetExportedValue <IThreadingContext>(),
diagnosticService, logger, fixers, SpecializedCollections.EmptyEnumerable <Lazy <IConfigurationFixProvider, CodeChangeProviderMetadata> >());
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
var unused = await fixService.GetMostSevereFixableDiagnosticAsync(document, TextSpan.FromBounds(0, 0), cancellationToken : CancellationToken.None);
var fixer1 = fixers.Single().Value as MockFixer;
var fixer2 = reference.Fixer as MockFixer;
// check to make sure both of them are called.
Assert.True(fixer1.Called);
Assert.True(fixer2.Called);
}
public async Task TestNuGetCompletionProvider()
{
var code = @"
using System.Diagnostics;
class Test {
void Method() {
Debug.Assert(true, ""$$"");
}
}
";
using var workspace = TestWorkspace.CreateCSharp(code, openDocuments: true);
var nugetCompletionProvider = new DebugAssertTestCompletionProvider();
var reference = new MockAnalyzerReference(nugetCompletionProvider);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var completionService = project.LanguageServices.GetRequiredService <CompletionService>();
var document = project.Documents.Single();
var caretPosition = workspace.DocumentWithCursor.CursorPosition ?? throw new InvalidOperationException();
var completions = await completionService.GetCompletionsAsync(document, caretPosition);
Assert.NotNull(completions);
var item = Assert.Single(completions.Items.Where(item => item.ProviderName == typeof(DebugAssertTestCompletionProvider).FullName));
Assert.Equal("Assertion failed", item.DisplayText);
}
public async Task TestGetFirstDiagnosticWithFixAsync()
{
var diagnosticService = new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var fixers = CreateFixers();
var code = @"
a
";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var logger = SpecializedCollections.SingletonEnumerable(new Lazy<IErrorLoggerService>(() => workspace.Services.GetService<IErrorLoggerService>()));
var fixService = new CodeFixService(
diagnosticService, logger, fixers, SpecializedCollections.EmptyEnumerable<Lazy<ISuppressionFixProvider, CodeChangeProviderMetadata>>());
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
var unused = await fixService.GetFirstDiagnosticWithFixAsync(document, TextSpan.FromBounds(0, 0), considerSuppressionFixes: false, cancellationToken: CancellationToken.None);
var fixer1 = fixers.Single().Value as MockFixer;
var fixer2 = reference.Fixer as MockFixer;
// check to make sure both of them are called.
Assert.True(fixer1.Called);
Assert.True(fixer2.Called);
}
}
private static async Task <ImmutableArray <CodeFixCollection> > GetAddedFixesAsync(CodeFixProvider codefix, DiagnosticAnalyzer diagnosticAnalyzer, bool exception = false, bool throwExceptionInFixerCreation = false)
{
var tuple = ServiceSetup(codefix, throwExceptionInFixerCreation: throwExceptionInFixerCreation);
using var workspace = tuple.workspace;
var errorReportingService = (TestErrorReportingService)workspace.Services.GetRequiredService <IErrorReportingService>();
var errorReported = false;
errorReportingService.OnError = message => errorReported = true;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager);
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)tuple.analyzerService;
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix, ImmutableArray.Create(diagnosticAnalyzer));
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), CodeActionOptions.DefaultProvider, isBlocking : false, CancellationToken.None);
if (exception)
{
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
Assert.Equal(exception || throwExceptionInFixerCreation, errorReported);
return(fixes);
}
public async Task TestGetFixesAsyncForDocumentDiagnosticAnalyzerAsync()
{
// TS has special DocumentDiagnosticAnalyzer that report 0 SupportedDiagnostics.
// We need to ensure that we don't skip these document analyzers
// when computing the diagnostics/code fixes for "Normal" priority bucket, which
// normally only execute those analyzers which report at least one fixable supported diagnostic.
var documentDiagnosticAnalyzer = new MockAnalyzerReference.MockDocumentDiagnosticAnalyzer(reportedDiagnosticIds: ImmutableArray <string> .Empty);
Assert.Empty(documentDiagnosticAnalyzer.SupportedDiagnostics);
var analyzers = ImmutableArray.Create <DiagnosticAnalyzer>(documentDiagnosticAnalyzer);
var codeFix = new MockFixer();
var analyzerReference = new MockAnalyzerReference(codeFix, analyzers);
// Verify no callbacks received at initialization.
Assert.False(documentDiagnosticAnalyzer.ReceivedCallback);
var tuple = ServiceSetup(codeFix, includeConfigurationFixProviders: false);
using var workspace = tuple.workspace;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
// Verify both analyzers are executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Normal'.
_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
priority : CodeActionRequestPriority.Normal, CodeActionOptions.DefaultProvider, isBlocking : false,
addOperationScope : _ => null, cancellationToken : CancellationToken.None);
Assert.True(documentDiagnosticAnalyzer.ReceivedCallback);
}
private async Task <ImmutableArray <CodeFixCollection> > GetNuGetAndVsixCodeFixersCoreAsync(
NuGetCodeFixProvider?nugetFixer,
VsixCodeFixProvider?vsixFixer,
MockAnalyzerReference.MockDiagnosticAnalyzer?diagnosticAnalyzer = null)
{
var code = @"class C { }";
var diagnosticService = new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var vsixFixers = vsixFixer != null
? SpecializedCollections.SingletonEnumerable(new Lazy <CodeFixProvider, CodeChangeProviderMetadata>(() => vsixFixer, new CodeChangeProviderMetadata(name: nameof(VsixCodeFixProvider), languages: LanguageNames.CSharp)))
: SpecializedCollections.EmptyEnumerable <Lazy <CodeFixProvider, CodeChangeProviderMetadata> >();
using var workspace = TestWorkspace.CreateCSharp(code, openDocuments: true);
var logger = SpecializedCollections.SingletonEnumerable(new Lazy <IErrorLoggerService>(() => workspace.Services.GetRequiredService <IErrorLoggerService>()));
var fixService = new CodeFixService(
workspace.ExportProvider.GetExportedValue <IThreadingContext>(),
diagnosticService, logger, vsixFixers, SpecializedCollections.EmptyEnumerable <Lazy <IConfigurationFixProvider, CodeChangeProviderMetadata> >());
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
diagnosticAnalyzer ??= new MockAnalyzerReference.MockDiagnosticAnalyzer();
var analyzers = ImmutableArray.Create <DiagnosticAnalyzer>(diagnosticAnalyzer);
var reference = new MockAnalyzerReference(nugetFixer, analyzers);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
return(await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes : false, cancellationToken : CancellationToken.None));
}
public async Task TestGetFixesAsyncWithDuplicateDiagnostics()
{
var codeFix = new MockFixer();
// Add duplicate analyzers to get duplicate diagnostics.
var analyzerReference = new MockAnalyzerReference(
codeFix,
ImmutableArray.Create <DiagnosticAnalyzer>(
new MockAnalyzerReference.MockDiagnosticAnalyzer(),
new MockAnalyzerReference.MockDiagnosticAnalyzer()));
var tuple = ServiceSetup(codeFix);
using var workspace = tuple.workspace;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
// Verify that we do not crash when computing fixes.
var options = CodeActionOptions.Default;
_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
// Verify that code fix is invoked with both the diagnostics in the context,
// i.e. duplicate diagnostics are not silently discarded by the CodeFixService.
Assert.Equal(2, codeFix.ContextDiagnosticsCount);
}
public void TestGetFirstDiagnosticWithFixAsync()
{
var diagnosticService = new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var fixers = CreateFixers();
var code = @"
a
";
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(code))
{
var logger = SpecializedCollections.SingletonEnumerable(new Lazy <IErrorLoggerService>(() => workspace.Services.GetService <IErrorLoggerService>()));
var fixService = new CodeFixService(
diagnosticService, logger, fixers, SpecializedCollections.EmptyEnumerable <Lazy <ISuppressionFixProvider, CodeChangeProviderMetadata> >());
var incrementalAnalzyer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalzyer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
var unused = fixService.GetFirstDiagnosticWithFixAsync(document, TextSpan.FromBounds(0, 0), considerSuppressionFixes: false, cancellationToken: CancellationToken.None).Result;
var fixer1 = fixers.Single().Value as MockFixer;
var fixer2 = reference.Fixer as MockFixer;
// check to make sure both of them are called.
Assert.True(fixer1.Called);
Assert.True(fixer2.Called);
}
}
private static void GetDocumentAndExtensionManager(TestDiagnosticAnalyzerService diagnosticService, TestWorkspace workspace, out Document document, out EditorLayerExtensionManager.ExtensionManager extensionManager)
{
var incrementalAnalzyer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalzyer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
extensionManager = document.Project.Solution.Workspace.Services.GetService <IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
}
private async Task GetAddedFixesAsync(CodeFixProvider codefix)
{
var tuple = ServiceSetup(codefix);
using var workspace = tuple.Item1;
GetDocumentAndExtensionManager(tuple.Item2, workspace, out var document, out var extensionManager);
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)tuple.Item2;
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = await tuple.Item3.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes : true, cancellationToken : CancellationToken.None);
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
public void GetAddedFixes(CodeFixProvider codefix)
{
TestDiagnosticAnalyzerService diagnosticService;
CodeFixService fixService;
IErrorLoggerService errorLogger;
using (var workspace = ServiceSetup(codefix, out diagnosticService, out fixService, out errorLogger))
{
Document document;
EditorLayerExtensionManager.ExtensionManager extensionManager;
GetDocumentAndExtensionManager(diagnosticService, workspace, out document, out extensionManager);
var incrementalAnalzyer = (IIncrementalAnalyzerProvider)diagnosticService;
var analyzer = incrementalAnalzyer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: true, cancellationToken: CancellationToken.None).Result;
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
}
public async Task TestGetFixesAsyncForFixableAndNonFixableAnalyzersAsync()
{
var codeFix = new MockFixer();
var analyzerWithFix = new MockAnalyzerReference.MockDiagnosticAnalyzer();
Assert.Equal(codeFix.FixableDiagnosticIds.Single(), analyzerWithFix.SupportedDiagnostics.Single().Id);
var analyzerWithoutFix = new MockAnalyzerReference.MockDiagnosticAnalyzer("AnalyzerWithoutFixId", "Category");
var analyzers = ImmutableArray.Create <DiagnosticAnalyzer>(analyzerWithFix, analyzerWithoutFix);
var analyzerReference = new MockAnalyzerReference(codeFix, analyzers);
// Verify no callbacks received at initialization.
Assert.False(analyzerWithFix.ReceivedCallback);
Assert.False(analyzerWithoutFix.ReceivedCallback);
var tuple = ServiceSetup(codeFix, includeConfigurationFixProviders: true);
using var workspace = tuple.workspace;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager, analyzerReference);
var options = CodeActionOptions.Default;
// Verify only analyzerWithFix is executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Normal'.
_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
priority : CodeActionRequestPriority.Normal, options,
addOperationScope : _ => null, cancellationToken : CancellationToken.None);
Assert.True(analyzerWithFix.ReceivedCallback);
Assert.False(analyzerWithoutFix.ReceivedCallback);
// Verify both analyzerWithFix and analyzerWithoutFix are executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Lowest'.
_ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
priority : CodeActionRequestPriority.Lowest, options,
addOperationScope : _ => null, cancellationToken : CancellationToken.None);
Assert.True(analyzerWithFix.ReceivedCallback);
Assert.True(analyzerWithoutFix.ReceivedCallback);
}
public async Task TestGetFirstDiagnosticWithFixAsync()
{
var fixers = CreateFixers();
var code = @"
a
";
using var workspace = TestWorkspace.CreateCSharp(code, composition: s_compositionWithMockDiagnosticUpdateSourceRegistrationService, openDocuments: true);
Assert.IsType <MockDiagnosticUpdateSourceRegistrationService>(workspace.GetService <IDiagnosticUpdateSourceRegistrationService>());
var diagnosticService = Assert.IsType <DiagnosticAnalyzerService>(workspace.GetService <IDiagnosticAnalyzerService>());
var analyzerReference = new TestAnalyzerReferenceByLanguage(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference }));
var logger = SpecializedCollections.SingletonEnumerable(new Lazy <IErrorLoggerService>(() => workspace.Services.GetRequiredService <IErrorLoggerService>()));
var fixService = new CodeFixService(
diagnosticService, logger, fixers, SpecializedCollections.EmptyEnumerable <Lazy <IConfigurationFixProvider, CodeChangeProviderMetadata> >());
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var document = project.Documents.Single();
var unused = await fixService.GetMostSevereFixAsync(
document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, CodeActionOptions.DefaultProvider, isBlocking : false, CancellationToken.None);
var fixer1 = (MockFixer)fixers.Single().Value;
var fixer2 = (MockFixer)reference.Fixer !;
// check to make sure both of them are called.
Assert.True(fixer1.Called);
Assert.True(fixer2.Called);
}
public async Task TestNuGetCompletionProvider()
{
var code = @"
using System.Diagnostics;
class Test {
void Method() {
Debug.Assert(true, ""$$"");
}
}
";
using var workspace = TestWorkspace.CreateCSharp(code, openDocuments: true);
var nugetCompletionProvider = new DebugAssertTestCompletionProvider();
var reference = new MockAnalyzerReference(nugetCompletionProvider);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
var completionService = project.LanguageServices.GetRequiredService <CompletionService>();
var document = project.Documents.Single();
var caretPosition = workspace.DocumentWithCursor.CursorPosition ?? throw new InvalidOperationException();
var completions = await completionService.GetCompletionsAsync(document, caretPosition, CompletionOptions.Default, OptionValueSet.Empty);
Assert.False(completions.IsEmpty);
var item = Assert.Single(completions.ItemsList.Where(item => item.ProviderName == typeof(DebugAssertTestCompletionProvider).FullName));
Assert.Equal(nameof(DebugAssertTestCompletionProvider), item.DisplayText);
var expectedDescriptionText = nameof(DebugAssertTestCompletionProvider);
var actualDescriptionText = (await completionService.GetDescriptionAsync(document, item, CompletionOptions.Default, SymbolDescriptionOptions.Default).ConfigureAwait(false)) !.Text;
Assert.Equal(expectedDescriptionText, actualDescriptionText);
var expectedChange = new TextChange(item.Span, nameof(DebugAssertTestCompletionProvider));
var actualChange = (await completionService.GetChangeAsync(document, item).ConfigureAwait(false)).TextChange;
Assert.Equal(expectedChange, actualChange);
}
private static async Task <ImmutableArray <CodeFixCollection> > GetAddedFixesAsync(CodeFixProvider codefix, DiagnosticAnalyzer diagnosticAnalyzer, bool exception = false, bool throwExceptionInFixerCreation = false)
{
var tuple = ServiceSetup(codefix, throwExceptionInFixerCreation: throwExceptionInFixerCreation);
using var workspace = tuple.workspace;
GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager);
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)tuple.analyzerService;
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix, ImmutableArray.Create(diagnosticAnalyzer));
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeConfigurationFixes : true, cancellationToken : CancellationToken.None);
if (exception)
{
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
return(fixes);
}
public async Task GetAddedFixesAsync(CodeFixProvider codefix)
{
var tuple = await ServiceSetupAsync(codefix);
using (var workspace = tuple.Item1)
{
Document document;
EditorLayerExtensionManager.ExtensionManager extensionManager;
GetDocumentAndExtensionManager(tuple.Item2, workspace, out document, out extensionManager);
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)tuple.Item2;
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = await tuple.Item3.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: true, cancellationToken: CancellationToken.None);
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
}
public void GetAddedFixes(CodeFixProvider codefix)
{
TestDiagnosticAnalyzerService diagnosticService;
CodeFixService fixService;
IErrorLoggerService errorLogger;
using (var workspace = ServiceSetup(codefix, out diagnosticService, out fixService, out errorLogger))
{
Document document;
EditorLayerExtensionManager.ExtensionManager extensionManager;
GetDocumentAndExtensionManager(diagnosticService, workspace, out document, out extensionManager);
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference(codefix);
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
var fixes = fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), includeSuppressionFixes: true, cancellationToken: CancellationToken.None).Result;
Assert.True(extensionManager.IsDisabled(codefix));
Assert.False(extensionManager.IsIgnored(codefix));
}
}
private static void GetDocumentAndExtensionManager(TestDiagnosticAnalyzerService diagnosticService, TestWorkspace workspace, out Document document, out EditorLayerExtensionManager.ExtensionManager extensionManager)
{
var incrementalAnalyzer = (IIncrementalAnalyzerProvider)diagnosticService;
// register diagnostic engine to solution crawler
var analyzer = incrementalAnalyzer.CreateIncrementalAnalyzer(workspace);
var reference = new MockAnalyzerReference();
var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
document = project.Documents.Single();
extensionManager = document.Project.Solution.Workspace.Services.GetService<IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
}
