internal static IList <ITagSpan <IErrorTag> > GetErrorsFromUpdateSource(TestWorkspace workspace, TestHostDocument document, DiagnosticsUpdatedArgs updateArgs)
{
var source = new TestDiagnosticUpdateSource();
var listener = new AsynchronousOperationListener();
var listeners = AsynchronousOperationListener.CreateListeners(
ValueTuple.Create(FeatureAttribute.DiagnosticService, listener),
ValueTuple.Create(FeatureAttribute.ErrorSquiggles, listener));
var optionsService = workspace.Services.GetService <IOptionService>();
var diagnosticService = new DiagnosticService(SpecializedCollections.SingletonEnumerable <IDiagnosticUpdateSource>(source), listeners);
var foregroundService = workspace.GetService <IForegroundNotificationService>(); //new TestForegroundNotificationService();
var buffer = document.GetTextBuffer();
var provider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
var tagger = provider.CreateTagger <IErrorTag>(buffer);
using (var disposable = tagger as IDisposable)
{
source.RaiseDiagnosticsUpdated(updateArgs);
listener.CreateWaitTask().PumpingWait();
var snapshot = buffer.CurrentSnapshot;
var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray();
return(spans);
}
}
public async Task TestGetDiagnostics1()
{
using var workspace = new TestWorkspace(composition: FeaturesTestCompositions.Features);
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 = GetDiagnosticService(workspace);
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 diagnosticMode = DiagnosticMode.Default;
var data1 = await diagnosticService.GetPushDiagnosticsAsync(workspace, null, null, null, includeSuppressedDiagnostics : false, diagnosticMode, CancellationToken.None);
Assert.Equal(diagnostic, data1.Single());
var data2 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, null, null, includeSuppressedDiagnostics : false, diagnosticMode, CancellationToken.None);
Assert.Equal(diagnostic, data2.Single());
var data3 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, document.Id, null, includeSuppressedDiagnostics : false, diagnosticMode, CancellationToken.None);
Assert.Equal(diagnostic, data3.Single());
var data4 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, document.Id, id, includeSuppressedDiagnostics : false, diagnosticMode, CancellationToken.None);
Assert.Equal(diagnostic, data4.Single());
}
internal static async Task <IList <ITagSpan <IErrorTag> > > GetErrorsFromUpdateSource(
TestWorkspace workspace,
DiagnosticsUpdatedArgs updateArgs
)
{
var source = new TestDiagnosticUpdateSource(workspace);
using (
var wrapper = new DiagnosticTaggerWrapper <TProvider, IErrorTag>(
workspace,
updateSource: source
)
)
{
var tagger = wrapper.TaggerProvider.CreateTagger <IErrorTag>(
workspace.Documents.First().GetTextBuffer()
);
using (var disposable = tagger as IDisposable)
{
source.RaiseDiagnosticsUpdated(updateArgs);
await wrapper.WaitForTags();
var snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
var spans = tagger
.GetTags(snapshot.GetSnapshotSpanCollection())
.ToImmutableArray();
return(spans);
}
}
}
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());
}
internal static IList <ITagSpan <IErrorTag> > GetErrorsFromUpdateSource(TestWorkspace workspace, TestHostDocument document, DiagnosticsUpdatedArgs updateArgs)
{
var source = new TestDiagnosticUpdateSource();
var diagnosticWaiter = new DiagnosticServiceWaiter();
var diagnosticListeners = SpecializedCollections.SingletonEnumerable(new Lazy <IAsynchronousOperationListener, FeatureMetadata>(
() => diagnosticWaiter, new FeatureMetadata(new Dictionary <string, object>()
{
{ "FeatureName", FeatureAttribute.DiagnosticService }
})));
var optionsService = workspace.Services.GetService <IOptionService>();
var diagnosticService = new DiagnosticService(SpecializedCollections.SingletonEnumerable <IDiagnosticUpdateSource>(source), diagnosticListeners);
var squiggleWaiter = new ErrorSquiggleWaiter();
var foregroundService = new TestForegroundNotificationService();
var buffer = document.GetTextBuffer();
var taggerSource = new DiagnosticsSquiggleTaggerProvider.TagSource(buffer, foregroundService, diagnosticService, optionsService, squiggleWaiter);
source.RaiseDiagnosticsUpdated(updateArgs);
diagnosticWaiter.CreateWaitTask().PumpingWait();
squiggleWaiter.CreateWaitTask().PumpingWait();
var snapshot = buffer.CurrentSnapshot;
var intervalTree = taggerSource.GetTagIntervalTreeForBuffer(buffer);
var spans = intervalTree.GetIntersectingSpans(new SnapshotSpan(snapshot, 0, snapshot.Length));
taggerSource.TestOnly_Dispose();
return(spans);
}
internal static IList<ITagSpan<IErrorTag>> GetErrorsFromUpdateSource(TestWorkspace workspace, TestHostDocument document, DiagnosticsUpdatedArgs updateArgs)
{
var source = new TestDiagnosticUpdateSource();
var listener = new AsynchronousOperationListener();
var listeners = AsynchronousOperationListener.CreateListeners(
ValueTuple.Create(FeatureAttribute.DiagnosticService, listener),
ValueTuple.Create(FeatureAttribute.ErrorSquiggles, listener));
var optionsService = workspace.Services.GetService<IOptionService>();
var diagnosticService = new DiagnosticService(SpecializedCollections.SingletonEnumerable<IDiagnosticUpdateSource>(source), listeners);
var foregroundService = workspace.GetService<IForegroundNotificationService>(); //new TestForegroundNotificationService();
var buffer = document.GetTextBuffer();
var provider = new DiagnosticsSquiggleTaggerProvider(optionsService, diagnosticService, foregroundService, listeners);
var tagger = provider.CreateTagger<IErrorTag>(buffer);
source.RaiseDiagnosticsUpdated(updateArgs);
listener.CreateWaitTask().PumpingWait();
var snapshot = buffer.CurrentSnapshot;
var spans = tagger.GetTags(new NormalizedSnapshotSpanCollection(new SnapshotSpan(snapshot, 0, snapshot.Length))).ToImmutableArray();
((IDisposable)tagger).Dispose();
return spans;
}
public void TestGetDiagnostics1()
{
using (var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic))
{
var set = 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(AggregateAsynchronousOperationListener.EmptyListeners);
diagnosticService.Register(source);
diagnosticService.DiagnosticsUpdated += (s, o) => { set.Set(); };
var id = Tuple.Create(workspace, document);
var diagnostic = RaiseDiagnosticEvent(set, 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 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();
}
}
}
private static DiagnosticData RaiseDiagnosticEvent(
ManualResetEvent set,
TestDiagnosticUpdateSource source,
TestWorkspace workspace,
ProjectId projectId,
DocumentId documentId,
object id
)
{
set.Reset();
var diagnostic = CreateDiagnosticData(projectId, documentId);
source.RaiseDiagnosticsUpdatedEvent(
DiagnosticsUpdatedArgs.DiagnosticsCreated(
id,
workspace,
workspace.CurrentSolution,
projectId,
documentId,
ImmutableArray.Create(diagnostic)
)
);
set.WaitOne();
return(diagnostic);
}
public void TestGetDiagnostics1()
{
using (var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic))
{
var set = 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(SpecializedCollections.SingletonCollection(source), AggregateAsynchronousOperationListener.EmptyListeners);
diagnosticService.DiagnosticsUpdated += (s, o) => { set.Set(); };
var id = Tuple.Create(workspace, document);
var diagnostic = RaiseDiagnosticEvent(set, source, workspace, document.Project.Id, document.Id, id);
var data1 = diagnosticService.GetDiagnostics(workspace, null, null, null, CancellationToken.None);
Assert.Equal(diagnostic, data1.Single());
var data2 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, null, null, CancellationToken.None);
Assert.Equal(diagnostic, data2.Single());
var data3 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, null, CancellationToken.None);
Assert.Equal(diagnostic, data3.Single());
var data4 = diagnosticService.GetDiagnostics(workspace, document.Project.Id, document.Id, id, CancellationToken.None);
Assert.Equal(diagnostic, data4.Single());
}
}
internal static IList<ITagSpan<IErrorTag>> GetErrorsFromUpdateSource(TestWorkspace workspace, TestHostDocument document, DiagnosticsUpdatedArgs updateArgs)
{
var source = new TestDiagnosticUpdateSource();
var diagnosticWaiter = new DiagnosticServiceWaiter();
var diagnosticListeners = SpecializedCollections.SingletonEnumerable(new Lazy<IAsynchronousOperationListener, FeatureMetadata>(
() => diagnosticWaiter, new FeatureMetadata(new Dictionary<string, object>() { { "FeatureName", FeatureAttribute.DiagnosticService } })));
var optionsService = workspace.Services.GetService<IOptionService>();
var diagnosticService = new DiagnosticService(SpecializedCollections.SingletonEnumerable<IDiagnosticUpdateSource>(source), diagnosticListeners);
var squiggleWaiter = new ErrorSquiggleWaiter();
var foregroundService = new TestForegroundNotificationService();
var buffer = document.GetTextBuffer();
var taggerSource = new DiagnosticsSquiggleTaggerProvider.TagSource(buffer, foregroundService, diagnosticService, optionsService, squiggleWaiter);
source.RaiseDiagnosticsUpdated(updateArgs);
diagnosticWaiter.CreateWaitTask().PumpingWait();
squiggleWaiter.CreateWaitTask().PumpingWait();
var snapshot = buffer.CurrentSnapshot;
var intervalTree = taggerSource.GetTagIntervalTreeForBuffer(buffer);
var spans = intervalTree.GetIntersectingSpans(new SnapshotSpan(snapshot, 0, snapshot.Length));
taggerSource.TestOnly_Dispose();
return spans;
}
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 async Task TestGetDiagnostics2()
{
using var workspace = new TestWorkspace(composition: FeaturesTestCompositions.Features);
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 = GetDiagnosticService(workspace);
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 = await diagnosticService.GetPushDiagnosticsAsync(workspace, null, null, null, includeSuppressedDiagnostics : false, InternalDiagnosticsOptions.NormalDiagnosticMode, CancellationToken.None);
Assert.Equal(5, data1.Count());
var data2 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, null, null, includeSuppressedDiagnostics : false, InternalDiagnosticsOptions.NormalDiagnosticMode, CancellationToken.None);
Assert.Equal(4, data2.Count());
var data3 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, null, id3, includeSuppressedDiagnostics : false, InternalDiagnosticsOptions.NormalDiagnosticMode, CancellationToken.None);
Assert.Equal(1, data3.Count());
var data4 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, document.Id, null, includeSuppressedDiagnostics : false, InternalDiagnosticsOptions.NormalDiagnosticMode, CancellationToken.None);
Assert.Equal(2, data4.Count());
var data5 = await diagnosticService.GetPushDiagnosticsAsync(workspace, document.Project.Id, document.Id, id, includeSuppressedDiagnostics : false, InternalDiagnosticsOptions.NormalDiagnosticMode, CancellationToken.None);
Assert.Equal(1, data5.Count());
}
internal static async Task<IList<ITagSpan<IErrorTag>>> GetErrorsFromUpdateSource(TestWorkspace workspace, TestHostDocument document, DiagnosticsUpdatedArgs updateArgs)
{
var source = new TestDiagnosticUpdateSource();
using (var wrapper = new DiagnosticTaggerWrapper(workspace, source))
{
var tagger = wrapper.TaggerProvider.CreateTagger<IErrorTag>(workspace.Documents.First().GetTextBuffer());
using (var disposable = tagger as IDisposable)
{
source.RaiseDiagnosticsUpdated(updateArgs);
await wrapper.WaitForTags();
var snapshot = workspace.Documents.First().GetTextBuffer().CurrentSnapshot;
var spans = tagger.GetTags(snapshot.GetSnapshotSpanCollection()).ToImmutableArray();
return spans;
}
}
}
public void TestGetDiagnostics2()
{
using (var workspace = new TestWorkspace(TestExportProvider.ExportProviderWithCSharpAndVisualBasic))
{
var set = 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(SpecializedCollections.SingletonCollection(source), AggregateAsynchronousOperationListener.EmptyListeners);
diagnosticService.DiagnosticsUpdated += (s, o) => { set.Set(); };
var id = Tuple.Create(workspace, document);
RaiseDiagnosticEvent(set, source, workspace, document.Project.Id, document.Id, id);
var id2 = Tuple.Create(workspace, document.Project, document);
RaiseDiagnosticEvent(set, source, workspace, document.Project.Id, document.Id, id2);
RaiseDiagnosticEvent(set, source, workspace, document2.Project.Id, document2.Id, Tuple.Create(workspace, document2));
var id3 = Tuple.Create(workspace, document.Project);
RaiseDiagnosticEvent(set, source, workspace, document.Project.Id, null, id3);
RaiseDiagnosticEvent(set, 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 async Task TestCleared()
{
using var workspace = new TestWorkspace(composition: FeaturesTestCompositions.Features);
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 = GetDiagnosticService(workspace);
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));
var diagnosticMode = DiagnosticMode.Default;
// confirm data is there.
var data1 = await diagnosticService.GetPushDiagnosticsAsync(workspace, null, null, null, includeSuppressedDiagnostics : false, diagnosticMode, 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 = await diagnosticService.GetPushDiagnosticsAsync(workspace, null, null, null, includeSuppressedDiagnostics : false, diagnosticMode, 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();
}
}
private static DiagnosticData RaiseDiagnosticEvent(ManualResetEvent set, TestDiagnosticUpdateSource source, TestWorkspace workspace, ProjectId project, DocumentId document, object id)
{
set.Reset();
var diagnostic = CreateDiagnosticData(workspace, project, document);
source.RaiseUpdateEvent(
new DiagnosticsUpdatedArgs(id, workspace, workspace.CurrentSolution, project, document, ImmutableArray.Create(diagnostic)));
set.WaitOne();
return diagnostic;
}
