public void TestCleared()
{
using (var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic))
{
var mutex = new ManualResetEvent(false);
var document = workspace.CurrentSolution.AddProject("TestProject", "TestProject", LanguageNames.CSharp).AddDocument("TestDocument", string.Empty);
var document2 = document.Project.AddDocument("TestDocument2", string.Empty);
var diagnosticService = new DiagnosticService(AsynchronousOperationListenerProvider.NullProvider);
var source1 = new TestDiagnosticUpdateSource(support: false, diagnosticData: null);
diagnosticService.Register(source1);
var source2 = new TestDiagnosticUpdateSource(support: false, diagnosticData: null);
diagnosticService.Register(source2);
diagnosticService.DiagnosticsUpdated += MarkSet;
// add bunch of data to the service for both sources
RaiseDiagnosticEvent(mutex, source1, workspace, document.Project.Id, document.Id, Tuple.Create(workspace, document));
RaiseDiagnosticEvent(mutex, source1, workspace, document.Project.Id, document.Id, Tuple.Create(workspace, document.Project, document));
RaiseDiagnosticEvent(mutex, source1, workspace, document2.Project.Id, document2.Id, Tuple.Create(workspace, document2));
RaiseDiagnosticEvent(mutex, source2, workspace, document.Project.Id, null, Tuple.Create(workspace, document.Project));
RaiseDiagnosticEvent(mutex, source2, workspace, null, null, Tuple.Create(workspace));
// confirm data is there.
var data1 = diagnosticService.GetDiagnostics(workspace, null, null, null, false, CancellationToken.None);
Assert.Equal(5, data1.Count());
diagnosticService.DiagnosticsUpdated -= MarkSet;
// confirm clear for a source
mutex.Reset();
var count = 0;
diagnosticService.DiagnosticsUpdated += MarkCalled;
source1.RaiseDiagnosticsClearedEvent();
mutex.WaitOne();
// confirm there are 2 data left
var data2 = diagnosticService.GetDiagnostics(workspace, null, null, null, false, CancellationToken.None);
Assert.Equal(2, data2.Count());
void MarkCalled(object sender, DiagnosticsUpdatedArgs args)
{
// event is serialized. no concurrent call
if (++count == 3)
{
mutex.Set();
}
}
void MarkSet(object sender, DiagnosticsUpdatedArgs args)
{
mutex.Set();
}
}
}
public void TestGetDiagnostics1()
{
using var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic);
var mutex = new ManualResetEvent(false);
var document = workspace.CurrentSolution.AddProject("TestProject", "TestProject", LanguageNames.CSharp).AddDocument("TestDocument", string.Empty);
var source = new TestDiagnosticUpdateSource(false, null);
var diagnosticService = new DiagnosticService(AsynchronousOperationListenerProvider.NullProvider);
diagnosticService.Register(source);
diagnosticService.DiagnosticsUpdated += (s, o) => { mutex.Set(); };
var id = Tuple.Create(workspace, document);
var diagnostic = RaiseDiagnosticEvent(mutex, source, workspace, document.Project.Id, document.Id, id);
var data1 = diagnosticService.GetDiagnostics(workspace, null, null, null, false, CancellationToken.None);
Assert.Equal(diagnostic, data1.Single());
var data2 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, null, null, false, CancellationToken.None);
Assert.Equal(diagnostic, data2.Single());
var data3 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, null, false, CancellationToken.None);
Assert.Equal(diagnostic, data3.Single());
var data4 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, id, false, CancellationToken.None);
Assert.Equal(diagnostic, data4.Single());
}
public DiagnosticTaggerWrapper(
TestWorkspace workspace,
IReadOnlyDictionary <string, ImmutableArray <DiagnosticAnalyzer> >?analyzerMap = null,
IDiagnosticUpdateSource?updateSource = null,
bool createTaggerProvider = true
)
{
_threadingContext = workspace.GetService <IThreadingContext>();
_listenerProvider = workspace.GetService <IAsynchronousOperationListenerProvider>();
var analyzerReference = new TestAnalyzerReferenceByLanguage(
analyzerMap ?? DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap()
);
workspace.TryApplyChanges(
workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference })
);
_workspace = workspace;
_registrationService =
(SolutionCrawlerRegistrationService)workspace.Services.GetRequiredService <ISolutionCrawlerRegistrationService>();
_registrationService.Register(workspace);
if (
!_registrationService
.GetTestAccessor()
.TryGetWorkCoordinator(workspace, out var coordinator)
)
{
throw new InvalidOperationException();
}
AnalyzerService = (DiagnosticAnalyzerService?)_registrationService
.GetTestAccessor()
.AnalyzerProviders.SelectMany(pair => pair.Value)
.SingleOrDefault(
lazyProvider =>
lazyProvider.Metadata.Name == WellKnownSolutionCrawlerAnalyzers.Diagnostic &&
lazyProvider.Metadata.HighPriorityForActiveFile
)
?.Value;
DiagnosticService =
(DiagnosticService)workspace.ExportProvider.GetExportedValue <IDiagnosticService>();
if (updateSource is object)
{
DiagnosticService.Register(updateSource);
}
if (createTaggerProvider)
{
_ = TaggerProvider;
}
}
public void TestGetDiagnostics2()
{
using var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic);
var mutex = new ManualResetEvent(false);
var document = workspace.CurrentSolution.AddProject("TestProject", "TestProject", LanguageNames.CSharp).AddDocument("TestDocument", string.Empty);
var document2 = document.Project.AddDocument("TestDocument2", string.Empty);
var source = new TestDiagnosticUpdateSource(false, null);
var diagnosticService = new DiagnosticService(
AsynchronousOperationListenerProvider.NullProvider, Array.Empty <Lazy <IEventListener, EventListenerMetadata> >());
diagnosticService.Register(source);
diagnosticService.DiagnosticsUpdated += (s, o) => { mutex.Set(); };
var id = Tuple.Create(workspace, document);
RaiseDiagnosticEvent(mutex, source, workspace, document.Project.Id, document.Id, id);
var id2 = Tuple.Create(workspace, document.Project, document);
RaiseDiagnosticEvent(mutex, source, workspace, document.Project.Id, document.Id, id2);
RaiseDiagnosticEvent(mutex, source, workspace, document2.Project.Id, document2.Id, Tuple.Create(workspace, document2));
var id3 = Tuple.Create(workspace, document.Project);
RaiseDiagnosticEvent(mutex, source, workspace, document.Project.Id, null, id3);
RaiseDiagnosticEvent(mutex, source, workspace, null, null, Tuple.Create(workspace));
var data1 = diagnosticService.GetDiagnostics(workspace, null, null, null, false, CancellationToken.None);
Assert.Equal(5, data1.Count());
var data2 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, null, null, false, CancellationToken.None);
Assert.Equal(4, data2.Count());
var data3 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, null, id3, false, CancellationToken.None);
Assert.Equal(1, data3.Count());
var data4 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, null, false, CancellationToken.None);
Assert.Equal(2, data4.Count());
var data5 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, id, false, CancellationToken.None);
Assert.Equal(1, data5.Count());
}
public DiagnosticTaggerWrapper(
TestWorkspace workspace,
IReadOnlyDictionary <string, ImmutableArray <DiagnosticAnalyzer> >?analyzerMap = null,
IDiagnosticUpdateSource?updateSource = null,
bool createTaggerProvider = true)
{
_threadingContext = workspace.GetService <IThreadingContext>();
_listenerProvider = workspace.GetService <IAsynchronousOperationListenerProvider>();
var analyzerReference = new TestAnalyzerReferenceByLanguage(analyzerMap ?? DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference }));
// Change the background analysis scope to OpenFiles instead of ActiveFile (default),
// so that every diagnostic tagger test does not need to mark test files as "active" file.
var csKey = new OptionKey2(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp);
var vbKey = new OptionKey2(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic);
workspace.SetOptions(workspace.Options
.WithChangedOption(csKey, BackgroundAnalysisScope.OpenFiles)
.WithChangedOption(vbKey, BackgroundAnalysisScope.OpenFiles));
_workspace = workspace;
_registrationService = (SolutionCrawlerRegistrationService)workspace.Services.GetRequiredService <ISolutionCrawlerRegistrationService>();
_registrationService.Register(workspace);
if (!_registrationService.GetTestAccessor().TryGetWorkCoordinator(workspace, out var coordinator))
{
throw new InvalidOperationException();
}
AnalyzerService = (DiagnosticAnalyzerService?)_registrationService.GetTestAccessor().AnalyzerProviders.SelectMany(pair => pair.Value).SingleOrDefault(lazyProvider => lazyProvider.Metadata.Name == WellKnownSolutionCrawlerAnalyzers.Diagnostic && lazyProvider.Metadata.HighPriorityForActiveFile)?.Value;
DiagnosticService = (DiagnosticService)workspace.ExportProvider.GetExportedValue <IDiagnosticService>();
if (updateSource is object)
{
DiagnosticService.Register(updateSource);
}
if (createTaggerProvider)
{
_ = TaggerProvider;
}
}
private DiagnosticTaggerWrapper(
TestWorkspace workspace,
Dictionary <string, DiagnosticAnalyzer[]> analyzerMap,
IDiagnosticUpdateSource updateSource,
bool createTaggerProvider)
{
_asyncListener = new AsynchronousOperationListener();
_listeners = AsynchronousOperationListener.CreateListeners(
ValueTuple.Create(FeatureAttribute.DiagnosticService, _asyncListener),
ValueTuple.Create(FeatureAttribute.ErrorSquiggles, _asyncListener));
if (analyzerMap != null || updateSource == null)
{
AnalyzerService = CreateDiagnosticAnalyzerService(analyzerMap, _asyncListener);
}
if (updateSource == null)
{
updateSource = AnalyzerService;
}
_workspace = workspace;
_registrationService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>();
_registrationService.Register(workspace);
DiagnosticService = new DiagnosticService(_listeners);
DiagnosticService.Register(updateSource);
if (createTaggerProvider)
{
var taggerProvider = this.TaggerProvider;
}
if (AnalyzerService != null)
{
_incrementalAnalyzers = ImmutableArray.Create(AnalyzerService.CreateIncrementalAnalyzer(workspace));
_solutionCrawlerService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
}
}
private DiagnosticTaggerWrapper(
TestWorkspace workspace,
Dictionary <string, DiagnosticAnalyzer[]> analyzerMap,
IDiagnosticUpdateSource updateSource,
bool createTaggerProvider)
{
_threadingContext = workspace.GetService <IThreadingContext>();
_listenerProvider = workspace.GetService <IAsynchronousOperationListenerProvider>();
if (analyzerMap != null || updateSource == null)
{
AnalyzerService = CreateDiagnosticAnalyzerService(analyzerMap, _listenerProvider.GetListener(FeatureAttribute.DiagnosticService));
}
if (updateSource == null)
{
updateSource = AnalyzerService;
}
_workspace = workspace;
_registrationService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>();
_registrationService.Register(workspace);
DiagnosticService = new DiagnosticService(_listenerProvider, Array.Empty <Lazy <IEventListener, EventListenerMetadata> >());
DiagnosticService.Register(updateSource);
if (createTaggerProvider)
{
var taggerProvider = this.TaggerProvider;
}
if (AnalyzerService != null)
{
_incrementalAnalyzers = ImmutableArray.Create(AnalyzerService.CreateIncrementalAnalyzer(workspace));
_solutionCrawlerService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
}
}
public DiagnosticTaggerWrapper(
TestWorkspace workspace,
IReadOnlyDictionary <string, ImmutableArray <DiagnosticAnalyzer> >?analyzerMap = null,
IDiagnosticUpdateSource?updateSource = null,
bool createTaggerProvider = true)
{
_threadingContext = workspace.GetService <IThreadingContext>();
_listenerProvider = workspace.GetService <IAsynchronousOperationListenerProvider>();
if (updateSource == null)
{
updateSource = AnalyzerService = new MyDiagnosticAnalyzerService(_listenerProvider.GetListener(FeatureAttribute.DiagnosticService));
}
var analyzerReference = new TestAnalyzerReferenceByLanguage(analyzerMap ?? DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
workspace.TryApplyChanges(workspace.CurrentSolution.WithAnalyzerReferences(new[] { analyzerReference }));
_workspace = workspace;
_registrationService = workspace.Services.GetRequiredService <ISolutionCrawlerRegistrationService>();
_registrationService.Register(workspace);
DiagnosticService = new DiagnosticService(_listenerProvider, Array.Empty <Lazy <IEventListener, EventListenerMetadata> >());
DiagnosticService.Register(updateSource);
if (createTaggerProvider)
{
_ = TaggerProvider;
}
if (AnalyzerService != null)
{
_incrementalAnalyzers = ImmutableArray.Create(AnalyzerService.CreateIncrementalAnalyzer(workspace));
_solutionCrawlerService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
}
}
private DiagnosticTaggerWrapper(
TestWorkspace workspace,
DiagnosticAnalyzerService analyzerService,
IDiagnosticUpdateSource updateSource,
bool createTaggerProvider)
{
if (updateSource == null)
{
updateSource = analyzerService;
}
this.workspace = workspace;
this.registrationService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>();
registrationService.Register(workspace);
this.asyncListener = new AsynchronousOperationListener();
this.listeners = AsynchronousOperationListener.CreateListeners(
ValueTuple.Create(FeatureAttribute.DiagnosticService, asyncListener),
ValueTuple.Create(FeatureAttribute.ErrorSquiggles, asyncListener));
this.analyzerService = analyzerService;
this.diagnosticService = new DiagnosticService(listeners);
diagnosticService.Register(updateSource);
if (createTaggerProvider)
{
var taggerProvider = this.TaggerProvider;
}
if (analyzerService != null)
{
this.incrementalAnalyzers = ImmutableArray.Create(analyzerService.CreateIncrementalAnalyzer(workspace));
this.solutionCrawlerService = workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
}
}
public void InitializeDiagnosticsServices(Workspace workspace)
{
_ = ((IIncrementalAnalyzerProvider)_analyzerService).CreateIncrementalAnalyzer(workspace);
_diagnosticService.Register((IDiagnosticUpdateSource)_analyzerService);
}
