public TagComputer(
ITextBuffer subjectBuffer,
IForegroundNotificationService notificationService,
IAsynchronousOperationListener asyncListener,
ClassificationTypeMap typeMap,
SyntacticClassificationTaggerProvider taggerProvider)
{
_subjectBuffer = subjectBuffer;
_notificationService = notificationService;
_listener = asyncListener;
_typeMap = typeMap;
_taggerProvider = taggerProvider;
_workQueue = new AsynchronousSerialWorkQueue(asyncListener);
_reportChangeCancellationSource = new CancellationTokenSource();
_lastLineCache = new LastLineCache();
_workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer());
_workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged;
if (_workspaceRegistration.Workspace != null)
{
ConnectToWorkspace(_workspaceRegistration.Workspace);
}
}
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 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 void TestBackgroundCancel1()
{
// Ensure that we can cancel a background action.
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 actionRan = false;
worker.EnqueueBackgroundWork(() =>
{
actionRan = true;
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
Assert.False(cancellationToken.IsCancellationRequested);
taskRunningEvent.Set();
cancelEvent.WaitOne();
Assert.True(cancellationToken.IsCancellationRequested);
doneEvent.Set();
}, "Test", source.Token);
taskRunningEvent.WaitOne();
source.Cancel();
cancelEvent.Set();
doneEvent.WaitOne();
Assert.True(actionRan);
}
public TagComputer(
ITextBuffer subjectBuffer,
IForegroundNotificationService notificationService,
IAsynchronousOperationListener asyncListener,
ClassificationTypeMap typeMap,
SyntacticClassificationTaggerProvider taggerProvider,
IViewSupportsClassificationService viewSupportsClassificationServiceOpt,
ITextBufferAssociatedViewService associatedViewService,
IEditorClassificationService editorClassificationService,
string languageName)
{
_subjectBuffer = subjectBuffer;
_notificationService = notificationService;
_listener = asyncListener;
_typeMap = typeMap;
_taggerProvider = taggerProvider;
_viewSupportsClassificationServiceOpt = viewSupportsClassificationServiceOpt;
_associatedViewService = associatedViewService;
_editorClassificationService = editorClassificationService;
_languageName = languageName;
_workQueue = new AsynchronousSerialWorkQueue(asyncListener);
_reportChangeCancellationSource = new CancellationTokenSource();
_lastLineCache = new LastLineCache();
_workspaceRegistration = Workspace.GetWorkspaceRegistration(subjectBuffer.AsTextContainer());
_workspaceRegistration.WorkspaceChanged += OnWorkspaceRegistrationChanged;
ConnectToWorkspace(_workspaceRegistration.Workspace);
}
internal TestAccessor(AsynchronousSerialWorkQueue asynchronousSerialWorkQueue)
{
_asynchronousSerialWorkQueue = asynchronousSerialWorkQueue;
}
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 void TestBackgroundCancelOneAction()
{
// Ensure that when a background action is cancelled the next
// one starts (if it has a different 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 source1 = new CancellationTokenSource();
var source2 = new CancellationTokenSource();
var token1 = source1.Token;
var token2 = source2.Token;
var action1Ran = false;
var action2Ran = false;
worker.EnqueueBackgroundWork(() =>
{
action1Ran = true;
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
Assert.False(token1.IsCancellationRequested);
taskRunningEvent.Set();
cancelEvent.WaitOne();
token1.ThrowIfCancellationRequested();
Assert.True(false);
}, "Test", source1.Token);
worker.EnqueueBackgroundWork(() =>
{
action2Ran = true;
Assert.NotSame(_foregroundSyncContext, SynchronizationContext.Current);
Assert.False(token2.IsCancellationRequested);
taskRunningEvent.Set();
cancelEvent.WaitOne();
doneEvent.Set();
}, "Test", source2.Token);
// Wait for the first task to start.
taskRunningEvent.WaitOne();
// Cancel it
source1.Cancel();
cancelEvent.Set();
// Wait for the second task to start.
taskRunningEvent.WaitOne();
cancelEvent.Set();
// Wait for the second task to complete.
doneEvent.WaitOne();
Assert.True(action1Ran);
Assert.True(action2Ran);
}