public void TestMultipleBackgroundAction()
{
// Test that background actions don't run at the same time.
var listener = new AggregateAsynchronousOperationListener(Enumerable.Empty <Lazy <IAsynchronousOperationListener, FeatureMetadata> >(), "Test");
var worker = new AsynchronousSerialWorkQueue(listener);
var doneEvent = new AutoResetEvent(false);
var action1Ran = false;
var action2Ran = false;
worker.EnqueueBackgroundWork(() =>
{
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
action1Ran = true;
// Simulate work to ensure that if tasks overlap that we will
// see it.
Thread.Sleep(1000);
Assert.False(action2Ran);
}, "Test", CancellationToken.None);
worker.EnqueueBackgroundWork(() =>
{
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
action2Ran = true;
doneEvent.Set();
}, "Test", CancellationToken.None);
doneEvent.WaitOne();
Assert.True(action1Ran);
Assert.True(action2Ran);
}
public NavigationBarControllerFactoryService(
IWaitIndicator waitIndicator,
[ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
{
_waitIndicator = waitIndicator;
_asyncListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.NavigationBar);
}
private void InitializeWorkspace(TestWorkspace workspace)
{
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(workspace, aggregateListener);
_aggregator = new NavigateToTestAggregator(_provider);
}
public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
{
if (!buffer.GetFeatureOnOffOption(InternalFeatureOnOffOptions.SyntacticColorizer))
{
return(null);
}
if (!_tagComputers.TryGetValue(buffer, out var tagComputer))
{
var asyncListener = new AggregateAsynchronousOperationListener(_asyncListeners, FeatureAttribute.Classification);
tagComputer = new TagComputer(buffer, _notificationService, asyncListener, _typeMap, this);
_tagComputers.Add(buffer, tagComputer);
}
tagComputer.IncrementReferenceCount();
var tagger = new Tagger(tagComputer);
var typedTagger = tagger as ITagger <T>;
if (typedTagger == null)
{
// Oops, we can't actually return this tagger, so just clean up
tagger.Dispose();
return(null);
}
else
{
return(typedTagger);
}
}
public AdornmentManagerTester()
{
_subjectBuffer = EditorFactory.CreateBuffer(TestExportProvider.ExportProviderWithCSharpAndVisualBasic, "Hi There");
_textView = new Mock <IWpfTextView>();
var aggregatorService = new Mock <IViewTagAggregatorFactoryService>();
_adornmentLayer = new Mock <IAdornmentLayer>();
_aggregator = new Mock <ITagAggregator <Tag> >();
var layerName = "LayerName";
_textView.Setup(tv => tv.GetAdornmentLayer(layerName)).Returns(_adornmentLayer.Object);
_textView.SetupGet(tv => tv.VisualElement).Returns(new FrameworkElement());
aggregatorService.Setup(a => a.CreateTagAggregator <Tag>(_textView.Object)).Returns(_aggregator.Object);
var textViewModel = new Mock <ITextViewModel>();
textViewModel.Setup(tvm => tvm.VisualBuffer).Returns(_subjectBuffer);
_textView.Setup(tv => tv.TextViewModel).Returns(textViewModel.Object);
var workspace = new TestWorkspace();
var listener = new AggregateAsynchronousOperationListener(
Enumerable.Empty <Lazy <IAsynchronousOperationListener, FeatureMetadata> >(),
FeatureAttribute.LineSeparators);
Manager = AdornmentManager <Tag> .Create(_textView.Object,
aggregatorService.Object,
listener,
adornmentLayerName : layerName);
}
public AbstractEncapsulateFieldCommandHandler(
IWaitIndicator waitIndicator,
ITextBufferUndoManagerProvider undoManager,
IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
{
_waitIndicator = waitIndicator;
_undoManager = undoManager;
_listener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.EncapsulateField);
}
internal void BeginSession(
EventHookupCommandHandler eventHookupCommandHandler,
ITextView textView,
ITextBuffer subjectBuffer,
AggregateAsynchronousOperationListener asyncListener,
Mutex testSessionHookupMutex)
{
CurrentSession = new EventHookupSession(this, eventHookupCommandHandler, textView, subjectBuffer, asyncListener, testSessionHookupMutex);
}
public void TestBackgroundCancelMultipleActions()
{
// Ensure that multiple background actions are cancelled if they
// use the same cancellation token.
var listener = new AggregateAsynchronousOperationListener(Enumerable.Empty <Lazy <IAsynchronousOperationListener, FeatureMetadata> >(), "Test");
var worker = new AsynchronousSerialWorkQueue(listener);
var taskRunningEvent = new AutoResetEvent(false);
var cancelEvent = new AutoResetEvent(false);
var doneEvent = new AutoResetEvent(false);
var source = new CancellationTokenSource();
var cancellationToken = source.Token;
var action1Ran = false;
var action2Ran = false;
worker.EnqueueBackgroundWork(() =>
{
action1Ran = true;
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
Assert.False(cancellationToken.IsCancellationRequested);
taskRunningEvent.Set();
cancelEvent.WaitOne();
cancellationToken.ThrowIfCancellationRequested();
Assert.True(false);
}, "Test", source.Token);
// We should not run this action.
worker.EnqueueBackgroundWork(() =>
{
action2Ran = true;
Assert.False(true);
}, "Test", source.Token);
taskRunningEvent.WaitOne();
source.Cancel();
cancelEvent.Set();
try
{
worker.WaitUntilCompletion_ForTestingPurposesOnly();
Assert.True(false);
}
catch (AggregateException ae)
{
Assert.IsAssignableFrom <OperationCanceledException>(ae.InnerException);
}
Assert.True(action1Ran);
Assert.False(action2Ran);
}
public ImplicitCacheMonitor(ProjectCacheService owner, int backOffTimeSpanInMS) :
base(AggregateAsynchronousOperationListener.CreateEmptyListener(),
backOffTimeSpanInMS,
CancellationToken.None)
{
_owner = owner;
_gate = new SemaphoreSlim(0);
Start();
}
// protected for testing purposes.
protected DiagnosticAnalyzerService(
HostAnalyzerManager hostAnalyzerManager,
AbstractHostDiagnosticUpdateSource hostDiagnosticUpdateSource,
IDiagnosticUpdateSourceRegistrationService registrationService,
IAsynchronousOperationListener listener = null) : this(registrationService)
{
_hostAnalyzerManager = hostAnalyzerManager;
_hostDiagnosticUpdateSource = hostDiagnosticUpdateSource;
_listener = listener ?? AggregateAsynchronousOperationListener.CreateEmptyListener();
}
public async Task TestTagsChangedForEntireFile()
{
var code =
@"class Program2
{
string x = @""/// <summary>$$
/// </summary>"";
}";
using (var workspace = TestWorkspace.CreateCSharp(code))
{
var document = workspace.Documents.First();
var subjectBuffer = document.TextBuffer;
var checkpoint = new Checkpoint();
var tagComputer = new SyntacticClassificationTaggerProvider.TagComputer(
subjectBuffer,
workspace.GetService <IForegroundNotificationService>(),
AggregateAsynchronousOperationListener.CreateEmptyListener(),
null,
new SyntacticClassificationTaggerProvider(null, null, null));
// Capture the expected value before the await, in case it changes.
var expectedLength = subjectBuffer.CurrentSnapshot.Length;
int? actualVersionNumber = null;
int? actualLength = null;
List <string> callstacks = new List <string>();
tagComputer.TagsChanged += (s, e) =>
{
actualVersionNumber = e.Span.Snapshot.Version.VersionNumber;
actualLength = e.Span.Length;
callstacks.Add(new StackTrace().ToString());
checkpoint.Release();
};
await checkpoint.Task;
Assert.Equal(1, actualVersionNumber);
Assert.Equal(expectedLength, actualLength);
Assert.Equal(1, callstacks.Count);
checkpoint = new Checkpoint();
// Now apply an edit that require us to reclassify more that just the current line
var snapshot = subjectBuffer.Insert(document.CursorPosition.Value, "\"");
expectedLength = snapshot.Length;
// NOTE: TagsChanged is raised on the UI thread, so there is no race between
// assigning expected here and verifying in the event handler, because the
// event handler can't run until we await.
await checkpoint.Task;
Assert.Equal(2, actualVersionNumber);
Assert.Equal(expectedLength, actualLength);
Assert.Equal(2, callstacks.Count);
}
}
private void InitializeWorkspace(TestWorkspace workspace)
{
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace,
_glyphServiceMock.Object,
aggregateListener,
workspace.ExportProvider.GetExportedValues <Lazy <INavigateToOptionsService, VisualStudioVersionMetadata> >());
_aggregator = new NavigateToTestAggregator(_provider);
}
protected AbstractGraphProvider(
IGlyphService glyphService,
SVsServiceProvider serviceProvider,
Workspace workspace,
IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
{
_glyphService = glyphService;
_serviceProvider = serviceProvider;
var asyncListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.GraphProvider);
_graphQueryManager = new GraphQueryManager(workspace, asyncListener);
}
public void Test_HeavyMultipleCall()
{
var asyncToken = AggregateAsynchronousOperationListener.CreateEmptyListener().BeginAsyncOperation("EnqueueTest");
var count = 0;
var loopCount = 100000;
var done = false;
for (var i = 0; i < loopCount; i++)
{
var index = i;
var retry = false;
_service.RegisterNotification(() =>
{
if (retry)
{
return(false);
}
var source = new CancellationTokenSource();
_service.RegisterNotification(() =>
{
for (int j = 0; j < 100; j++)
{
count++;
}
}, asyncToken, source.Token);
if ((index % 10) == 0)
{
source.Cancel();
retry = true;
return(retry);
}
if (index == loopCount - 1)
{
_service.RegisterNotification(() => { done = true; }, asyncToken, CancellationToken.None);
}
return(false);
}, asyncToken, CancellationToken.None);
}
PumpWait(ref done);
Assert.True(done);
Assert.Equal(count, 9000000);
Assert.True(Empty(_service));
}
public InlineRenameService(
IWaitIndicator waitIndicator,
ITextBufferAssociatedViewService textBufferAssociatedViewService,
ITextBufferFactoryService textBufferFactoryService,
[ImportMany] IEnumerable <IRefactorNotifyService> refactorNotifyServices,
[ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > listeners)
{
_waitIndicator = waitIndicator;
_textBufferAssociatedViewService = textBufferAssociatedViewService;
_textBufferFactoryService = textBufferFactoryService;
_refactorNotifyServices = refactorNotifyServices;
_aggregateListener = new AggregateAsynchronousOperationListener(listeners, FeatureAttribute.Rename);
}
private TestWorkspace SetupWorkspace(params string[] lines)
{
var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromLines(lines);
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace,
_glyphServiceMock.Object,
aggregateListener);
_aggregator = new NavigateToTestAggregator(_provider);
return(workspace);
}
public ITagger <T> CreateTagger <T>(ITextBuffer buffer) where T : ITag
{
if (!buffer.GetOption(InternalFeatureOnOffOptions.SyntacticColorizer))
{
return(null);
}
TagComputer tagComputer;
if (!_tagComputers.TryGetValue(buffer, out tagComputer))
{
var asyncListener = new AggregateAsynchronousOperationListener(_asyncListeners, FeatureAttribute.Classification);
var languageName = _contentTypesToLanguageNames.FirstOrDefault(x => buffer.ContentType.MatchesAny(x.Metadata.DefaultContentType))?.Metadata.Language;
var editorClassificationService = _editorClassificationLanguageServices.FirstOrDefault(x => x.Metadata.Language == languageName).Value as IEditorClassificationService;
if (editorClassificationService == null)
{
return(null);
}
tagComputer = new TagComputer(
buffer,
_notificationService,
asyncListener,
_typeMap,
this,
_viewSupportsClassificationServiceOpt,
_associatedViewService,
editorClassificationService,
languageName);
_tagComputers.Add(buffer, tagComputer);
}
tagComputer.IncrementReferenceCount();
var tagger = new Tagger(tagComputer);
var typedTagger = tagger as ITagger <T>;
if (typedTagger == null)
{
// Oops, we can't actually return this tagger, so just clean up
tagger.Dispose();
return(null);
}
else
{
return(typedTagger);
}
}
public async Task TestTagsChangedForEntireFile()
{
var code =
@"class Program2
{
string x = @""/// <summary>$$
/// </summary>"";
}";
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(code))
{
var document = workspace.Documents.First();
var subjectBuffer = document.TextBuffer;
var checkpoint = new Checkpoint();
var tagComputer = new SyntacticClassificationTaggerProvider.TagComputer(
subjectBuffer,
workspace.GetService <IForegroundNotificationService>(),
AggregateAsynchronousOperationListener.CreateEmptyListener(),
typeMap: null,
taggerProvider: new SyntacticClassificationTaggerProvider(
notificationService: null,
typeMap: null,
viewSupportsClassificationServiceOpt: null,
associatedViewService: null,
allLanguageServices: ImmutableArray <Lazy <ILanguageService, LanguageServiceMetadata> > .Empty,
contentTypes: ImmutableArray <Lazy <ILanguageService, ContentTypeLanguageMetadata> > .Empty,
asyncListeners: ImmutableArray <Lazy <IAsynchronousOperationListener, FeatureMetadata> > .Empty),
viewSupportsClassificationServiceOpt: null,
associatedViewService: null,
editorClassificationService: null,
languageName: null);
SnapshotSpan span = default(SnapshotSpan);
tagComputer.TagsChanged += (s, e) =>
{
span = e.Span;
checkpoint.Release();
};
await checkpoint.Task.ConfigureAwait(true);
checkpoint = new Checkpoint();
// Now apply an edit that require us to reclassify more that just the current line
subjectBuffer.Insert(document.CursorPosition.Value, "\"");
await checkpoint.Task.ConfigureAwait(true);
Assert.Equal(subjectBuffer.CurrentSnapshot.Length, span.Length);
}
}
private async Task <TestWorkspace> SetupWorkspaceAsync(params string[] files)
{
var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromFilesAsync(files, parseOptions : Options.Script);
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace,
_glyphServiceMock.Object,
aggregateListener);
_aggregator = new NavigateToTestAggregator(_provider);
return(workspace);
}
public EventHookupCommandHandler(
IInlineRenameService inlineRenameService,
Microsoft.CodeAnalysis.Editor.Host.IWaitIndicator waitIndicator,
IQuickInfoBroker quickInfoBroker,
[Import(AllowDefault = true)] IHACK_EventHookupDismissalOnBufferChangePreventerService prematureDismissalPreventer,
[ImportMany] IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
{
_inlineRenameService = inlineRenameService;
_waitIndicator = waitIndicator;
_prematureDismissalPreventer = prematureDismissalPreventer;
_asyncListener = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.EventHookup);
this.EventHookupSessionManager = new EventHookupSessionManager(prematureDismissalPreventer, quickInfoBroker);
}
private async Task <TestWorkspace> SetupWorkspaceAsync(string content)
{
var workspace = await TestWorkspace.CreateCSharpAsync(content);
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace,
_glyphServiceMock.Object,
aggregateListener);
_aggregator = new NavigateToTestAggregator(_provider);
return(workspace);
}
public void Test_Enqueue()
{
var asyncToken = AggregateAsynchronousOperationListener.CreateEmptyListener().BeginAsyncOperation("EnqueueTest");
var done = false;
var ran = false;
_service.RegisterNotification(() => { Thread.Sleep(100); }, asyncToken, CancellationToken.None);
_service.RegisterNotification(() => { /* do nothing */ }, asyncToken, CancellationToken.None);
_service.RegisterNotification(() => { ran = true; done = true; }, asyncToken, CancellationToken.None);
PumpWait(ref done);
Assert.True(ran);
Assert.True(Empty(_service));
}
private async Task <TestWorkspace> SetupWorkspaceAsync(string content)
{
var workspace = await TestWorkspace.CreateCSharpAsync(content, exportProvider : s_exportProvider);
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace,
_glyphServiceMock.Object,
aggregateListener,
workspace.ExportProvider.GetExportedValues <Lazy <INavigateToOptionsService, VisualStudioVersionMetadata> >());
_aggregator = new NavigateToTestAggregator(_provider);
return(workspace);
}
public async Task NavigateToGeneratedFiles()
{
using (var workspace = TestWorkspace.Create(@"
<Workspace>
<Project Language=""C#"" CommonReferences=""true"">
<Document FilePath=""File1.cs"">
namespace N
{
public partial class C
{
public void VisibleMethod() { }
}
}
</Document>
<Document FilePath=""File1.g.cs"">
namespace N
{
public partial class C
{
public void VisibleMethod_Generated() { }
}
}
</Document>
</Project>
</Workspace>
", exportProvider: s_exportProvider))
{
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(
workspace, _glyphServiceMock.Object, aggregateListener,
workspace.ExportProvider.GetExportedValues <Lazy <INavigateToHostVersionService, VisualStudioVersionMetadata> >());
_aggregator = new NavigateToTestAggregator(_provider);
var items = await _aggregator.GetItemsAsync("VisibleMethod");
var expectedItems = new List <NavigateToItem>()
{
new NavigateToItem("VisibleMethod", NavigateToItemKind.Method, "csharp", null, null, MatchKind.Exact, true, null),
new NavigateToItem("VisibleMethod_Generated", NavigateToItemKind.Method, "csharp", null, null, MatchKind.Prefix, true, null)
};
// The pattern matcher should match 'VisibleMethod' to both 'VisibleMethod' and 'VisibleMethod_Not', except that
// the _Not method is declared in a generated file.
VerifyNavigateToResultItems(expectedItems, items);
}
}
public SolutionChecksumUpdater(RemoteHostClientService service, CancellationToken shutdownToken) :
base(AggregateAsynchronousOperationListener.CreateEmptyListener(),
service.Workspace.Services.GetService <IGlobalOperationNotificationService>(),
service.Workspace.Options.GetOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS), shutdownToken)
{
_service = service;
_event = new SemaphoreSlim(initialCount: 0);
// start listening workspace change event
_service.Workspace.WorkspaceChanged += OnWorkspaceChanged;
// create its own cancellation token source
_globalOperationCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(shutdownToken);
Start();
}
public AbstractSnippetInfoService(
Shell.SVsServiceProvider serviceProvider,
Guid languageGuidForSnippets,
IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > asyncListeners)
{
AssertIsForeground();
if (serviceProvider != null)
{
var textManager = (IVsTextManager2)serviceProvider.GetService(typeof(SVsTextManager));
if (textManager.GetExpansionManager(out _expansionManager) == VSConstants.S_OK)
{
ComEventSink.Advise <IVsExpansionEvents>(_expansionManager, this);
_waiter = new AggregateAsynchronousOperationListener(asyncListeners, FeatureAttribute.Snippets);
_languageGuidForSnippets = languageGuidForSnippets;
PopulateSnippetCaches();
}
}
}
public void Test_Delay()
{
var asyncToken = AggregateAsynchronousOperationListener.CreateEmptyListener().BeginAsyncOperation("EnqueueTest");
bool done = false;
DateTime now = DateTime.UtcNow;
DateTime set = DateTime.UtcNow;
_service.RegisterNotification(() =>
{
set = DateTime.UtcNow;
done = true;
}, 50, asyncToken, CancellationToken.None);
PumpWait(ref done);
Assert.True(set.Subtract(now).TotalMilliseconds > 50);
Assert.True(Empty(_service));
}
public void NoNavigationToGeneratedFiles()
{
using (var workspace = TestWorkspaceFactory.CreateWorkspace(@"
<Workspace>
<Project Language=""C#"" CommonReferences=""true"">
<Document FilePath=""File1.cs"">
namespace N
{
public partial class C
{
public void VisibleMethod() { }
}
}
</Document>
<Document FilePath=""File1.g.cs"">
namespace N
{
public partial class C
{
public void VisibleMethod_Not() { }
}
}
</Document>
</Project>
</Workspace>
"))
{
var aggregateListener = AggregateAsynchronousOperationListener.CreateEmptyListener();
_provider = new NavigateToItemProvider(workspace, _glyphServiceMock.Object, aggregateListener);
_aggregator = new NavigateToTestAggregator(_provider);
var items = _aggregator.GetItems("VisibleMethod");
var expectedItems = new List <NavigateToItem>()
{
new NavigateToItem("VisibleMethod", NavigateToItemKind.Method, "csharp", null, null, MatchKind.Exact, true, null)
};
// The pattern matcher should match 'VisibleMethod' to both 'VisibleMethod' and 'VisibleMethod_Not', except that
// the _Not method is declared in a generated file.
VerifyNavigateToResultItems(expectedItems, items);
}
}
public void TestBackgroundAction()
{
var listener = new AggregateAsynchronousOperationListener(Enumerable.Empty <Lazy <IAsynchronousOperationListener, FeatureMetadata> >(), "Test");
var worker = new AsynchronousSerialWorkQueue(listener);
var doneEvent = new AutoResetEvent(initialState: false);
var actionRan = false;
worker.EnqueueBackgroundWork(() =>
{
// Assert.NotNull(SynchronizationContext.Current);
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
actionRan = true;
doneEvent.Set();
}, GetType().Name + ".TestBackgroundAction", CancellationToken.None);
doneEvent.WaitOne();
Assert.True(actionRan);
}
public async Task TestTagsChangedForEntireFile()
{
var code =
@"class Program2
{
string x = @""/// <summary>$$
/// </summary>"";
}";
using (var workspace = CSharpWorkspaceFactory.CreateWorkspaceFromFile(code))
{
var document = workspace.Documents.First();
var subjectBuffer = document.TextBuffer;
var checkpoint = new Checkpoint();
var tagComputer = new SyntacticClassificationTaggerProvider.TagComputer(
subjectBuffer,
workspace.GetService <IForegroundNotificationService>(),
AggregateAsynchronousOperationListener.CreateEmptyListener(),
null,
new SyntacticClassificationTaggerProvider(null, null, null));
SnapshotSpan span = default(SnapshotSpan);
tagComputer.TagsChanged += (s, e) =>
{
span = e.Span;
checkpoint.Release();
};
await checkpoint.Task.ConfigureAwait(true);
checkpoint = new Checkpoint();
// Now apply an edit that require us to reclassify more that just the current line
subjectBuffer.Insert(document.CursorPosition.Value, "\"");
await checkpoint.Task.ConfigureAwait(true);
Assert.Equal(subjectBuffer.CurrentSnapshot.Length, span.Length);
}
}
