public AsynchronousWorkerTests() { WpfTestCase.RequireWpfFact($"Tests are testing {nameof(AsynchronousSerialWorkQueue)} which is designed to run methods on the UI thread"); TestWorkspace.ResetThreadAffinity(); _foregroundSyncContext = SynchronizationContext.Current; Assert.NotNull(_foregroundSyncContext); }
public void TestSynchronousOutlining() { using (var workspace = TestWorkspace.CreateCSharp("class Program {\r\n\r\n}")) { WpfTestCase.RequireWpfFact($"{nameof(AsynchronousTaggerTests)}.{nameof(TestSynchronousOutlining)} creates asynchronous taggers"); var tagProvider = new VisualStudio14StructureTaggerProvider( workspace.GetService <IForegroundNotificationService>(), workspace.GetService <ITextEditorFactoryService>(), workspace.GetService <IEditorOptionsFactoryService>(), workspace.GetService <IProjectionBufferFactoryService>(), workspace.ExportProvider.GetExports <IAsynchronousOperationListener, FeatureMetadata>()); var document = workspace.Documents.First(); var textBuffer = document.TextBuffer; var tagger = tagProvider.CreateTagger <IOutliningRegionTag>(textBuffer); using (var disposable = (IDisposable)tagger) { // The very first all to get tags should return the single outlining span. var tags = tagger.GetAllTags(new NormalizedSnapshotSpanCollection(textBuffer.CurrentSnapshot.GetFullSpan()), CancellationToken.None); Assert.Equal(1, tags.Count()); } } }
protected async Task TestBraceHighlightingAsync(string markup, ParseOptions options = null) { using (var workspace = CreateWorkspace(markup, options)) { WpfTestCase.RequireWpfFact($"{nameof(AbstractBraceHighlightingTests)}.{nameof(TestBraceHighlightingAsync)} creates asynchronous taggers"); var provider = new BraceHighlightingViewTaggerProvider( GetBraceMatchingService(workspace), workspace.GetService <IForegroundNotificationService>(), AggregateAsynchronousOperationListener.EmptyListeners); var testDocument = workspace.Documents.First(); var buffer = testDocument.TextBuffer; var document = buffer.CurrentSnapshot.GetRelatedDocumentsWithChanges().FirstOrDefault(); var context = new TaggerContext <BraceHighlightTag>( document, buffer.CurrentSnapshot, new SnapshotPoint(buffer.CurrentSnapshot, testDocument.CursorPosition.Value)); await provider.ProduceTagsAsync_ForTestingPurposesOnly(context); var expectedHighlights = testDocument.SelectedSpans.Select(ts => ts.ToSpan()).OrderBy(s => s.Start).ToList(); var actualHighlights = context.tagSpans.Select(ts => ts.Span.Span).OrderBy(s => s.Start).ToList(); Assert.Equal(expectedHighlights, actualHighlights); } }
public IWpfTextView GetTextView() { if (_textView == null) { TestWorkspace.ResetThreadAffinity(); WpfTestCase.RequireWpfFact($"Creates an IWpfTextView through {nameof(TestHostDocument)}.{nameof(GetTextView)}"); var factory = _exportProvider.GetExportedValue <ITextEditorFactoryService>(); // Every default role but outlining. Starting in 15.2, the editor // OutliningManager imports JoinableTaskContext in a way that's // difficult to satisfy in our unit tests. Since we don't directly // depend on it, just disable it var roles = factory.CreateTextViewRoleSet(PredefinedTextViewRoles.Analyzable, PredefinedTextViewRoles.Document, PredefinedTextViewRoles.Editable, PredefinedTextViewRoles.Interactive, PredefinedTextViewRoles.Zoomable); _textView = factory.CreateTextView(this.TextBuffer, roles); if (this.CursorPosition.HasValue) { _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextSnapshot, CursorPosition.Value)); } else if (this.SelectedSpans.IsSingle()) { var span = this.SelectedSpans.Single(); _textView.Selection.Select(new SnapshotSpan(_textView.TextSnapshot, new Span(span.Start, span.Length)), false); } } return(_textView); }
IWpfTextView IInteractiveWindowEditorFactoryService.CreateTextView(IInteractiveWindow window, ITextBuffer buffer, ITextViewRoleSet roles) { WpfTestCase.RequireWpfFact($"Creates an IWpfTextView in {nameof(InteractiveWindowEditorsFactoryService)}"); var textView = _textEditorFactoryService.CreateTextView(buffer, roles); return(_textEditorFactoryService.CreateTextViewHost(textView, false).TextView); }
public async Task TestPreviewDiagnosticTaggerInPreviewPane() { using (var workspace = TestWorkspace.CreateCSharp("class { }", exportProvider: EditorServicesUtil.ExportProvider)) { // set up listener to wait until diagnostic finish running var diagnosticService = workspace.ExportProvider.GetExportedValue <IDiagnosticService>(); var hostDocument = workspace.Projects.First().Documents.First(); // make a change to remove squiggle var oldDocument = workspace.CurrentSolution.GetDocument(hostDocument.Id); var oldText = oldDocument.GetTextAsync().Result; var newDocument = oldDocument.WithText(oldText.WithChanges(new TextChange(new TextSpan(0, oldText.Length), "class C { }"))); // create a diff view WpfTestCase.RequireWpfFact($"{nameof(TestPreviewDiagnosticTaggerInPreviewPane)} creates a {nameof(DifferenceViewerPreview)}"); var previewFactoryService = workspace.ExportProvider.GetExportedValue <IPreviewFactoryService>(); using (var diffView = (DifferenceViewerPreview)(await previewFactoryService.CreateChangedDocumentPreviewViewAsync(oldDocument, newDocument, CancellationToken.None))) { var foregroundService = workspace.GetService <IForegroundNotificationService>(); var listenerProvider = workspace.ExportProvider.GetExportedValue <AsynchronousOperationListenerProvider>(); // set up tagger for both buffers var leftBuffer = diffView.Viewer.LeftView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First(); var leftProvider = new DiagnosticsSquiggleTaggerProvider(diagnosticService, foregroundService, listenerProvider); var leftTagger = leftProvider.CreateTagger <IErrorTag>(leftBuffer); using (var leftDisposable = leftTagger as IDisposable) { var rightBuffer = diffView.Viewer.RightView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First(); var rightProvider = new DiagnosticsSquiggleTaggerProvider(diagnosticService, foregroundService, listenerProvider); var rightTagger = rightProvider.CreateTagger <IErrorTag>(rightBuffer); using (var rightDisposable = rightTagger as IDisposable) { // wait for diagnostics and taggers await listenerProvider.WaitAllDispatcherOperationAndTasksAsync(FeatureAttribute.DiagnosticService, FeatureAttribute.ErrorSquiggles); // check left buffer var leftSnapshot = leftBuffer.CurrentSnapshot; var leftSpans = leftTagger.GetTags(leftSnapshot.GetSnapshotSpanCollection()).ToList(); Assert.Equal(1, leftSpans.Count); // check right buffer var rightSnapshot = rightBuffer.CurrentSnapshot; var rightSpans = rightTagger.GetTags(rightSnapshot.GetSnapshotSpanCollection()).ToList(); Assert.Equal(0, rightSpans.Count); } } } } }
public static DisposableTextView CreateView( string contentType, ExportProvider exportProvider, params string[] lines) { TestWorkspace.ResetThreadAffinity(); WpfTestCase.RequireWpfFact($"Creates an IWpfTextView through {nameof(EditorFactory)}.{nameof(CreateView)}"); var buffer = CreateBuffer(contentType, exportProvider, lines); return(exportProvider.GetExportedValue <ITextEditorFactoryService>().CreateDisposableTextView(buffer)); }
protected async Task <CodeElement> GetCodeElementAsync(params object[] path) { WpfTestCase.RequireWpfFact("Tests create CodeElements which use the affinitized CleanableWeakComHandleTable"); if (path.Length == 0) { throw new ArgumentException("path must be non-empty.", nameof(path)); } CodeElement codeElement = (await GetCodeModelAsync()).CodeElements.Item(path[0]); foreach (var pathElement in path.Skip(1)) { codeElement = codeElement.Children.Item(pathElement); } return(codeElement); }
public async Task TestCreateWithBufferNotInWorkspace() { // don't crash using (var workspace = await TestWorkspace.CreateCSharpAsync("")) { var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id); var contentTypeService = document.GetLanguageService <IContentTypeLanguageService>(); var contentType = contentTypeService.GetDefaultContentType(); var extraBuffer = workspace.ExportProvider.GetExportedValue <ITextBufferFactoryService>().CreateTextBuffer("", contentType); WpfTestCase.RequireWpfFact("Creates an IWpfTextView explicitly with an unrelated buffer"); using (var disposableView = workspace.ExportProvider.GetExportedValue <ITextEditorFactoryService>().CreateDisposableTextView(extraBuffer)) { var waiter = new Waiter(); var provider = new SemanticClassificationViewTaggerProvider( workspace.ExportProvider.GetExportedValue <IForegroundNotificationService>(), workspace.ExportProvider.GetExportedValue <ISemanticChangeNotificationService>(), workspace.ExportProvider.GetExportedValue <ClassificationTypeMap>(), SpecializedCollections.SingletonEnumerable( new Lazy <IAsynchronousOperationListener, FeatureMetadata>( () => waiter, new FeatureMetadata(new Dictionary <string, object>() { { "FeatureName", FeatureAttribute.Classification } })))); using (var tagger = (IDisposable)provider.CreateTagger <IClassificationTag>(disposableView.TextView, extraBuffer)) { using (var edit = extraBuffer.CreateEdit()) { edit.Insert(0, "class A { }"); edit.Apply(); } await waiter.CreateWaitTask(); } } } }
public IWpfTextView GetTextView() { if (_textView == null) { TestWorkspace.ResetThreadAffinity(); WpfTestCase.RequireWpfFact($"Creates an IWpfTextView through {nameof(TestHostDocument)}.{nameof(GetTextView)}"); _textView = _exportProvider.GetExportedValue <ITextEditorFactoryService>().CreateTextView(this.TextBuffer); if (this.CursorPosition.HasValue) { _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextSnapshot, CursorPosition.Value)); } else if (this.SelectedSpans.IsSingle()) { var span = this.SelectedSpans.Single(); _textView.Selection.Select(new SnapshotSpan(_textView.TextSnapshot, new Span(span.Start, span.Length)), false); } } return(_textView); }
public async Task TestPreviewDiagnosticTaggerInPreviewPane() { using (var workspace = TestWorkspace.CreateCSharp("class { }", exportProvider: EditorServicesUtil.ExportProvider)) { // set up listener to wait until diagnostic finish running var diagnosticService = workspace.ExportProvider.GetExportedValue <IDiagnosticService>() as DiagnosticService; // no easy way to setup waiter. kind of hacky way to setup waiter var source = new CancellationTokenSource(); var taskSource = new TaskCompletionSource <DiagnosticsUpdatedArgs>(); diagnosticService.DiagnosticsUpdated += (s, a) => { source.Cancel(); source = new CancellationTokenSource(); var cancellationToken = source.Token; Task.Delay(2000, cancellationToken).ContinueWith(t => taskSource.TrySetResult(a), CancellationToken.None, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current); }; var hostDocument = workspace.Projects.First().Documents.First(); // make a change to remove squiggle var oldDocument = workspace.CurrentSolution.GetDocument(hostDocument.Id); var oldText = oldDocument.GetTextAsync().Result; var newDocument = oldDocument.WithText(oldText.WithChanges(new TextChange(new TextSpan(0, oldText.Length), "class C { }"))); // create a diff view WpfTestCase.RequireWpfFact($"{nameof(TestPreviewDiagnosticTaggerInPreviewPane)} creates a {nameof(DifferenceViewerPreview)}"); var previewFactoryService = workspace.ExportProvider.GetExportedValue <IPreviewFactoryService>(); using (var diffView = (DifferenceViewerPreview)(await previewFactoryService.CreateChangedDocumentPreviewViewAsync(oldDocument, newDocument, CancellationToken.None))) { var foregroundService = workspace.GetService <IForegroundNotificationService>(); var waiter = new ErrorSquiggleWaiter(); var listeners = AsynchronousOperationListener.CreateListeners(FeatureAttribute.ErrorSquiggles, waiter); // set up tagger for both buffers var leftBuffer = diffView.Viewer.LeftView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First(); var leftProvider = new DiagnosticsSquiggleTaggerProvider(diagnosticService, foregroundService, listeners); var leftTagger = leftProvider.CreateTagger <IErrorTag>(leftBuffer); using (var leftDisposable = leftTagger as IDisposable) { var rightBuffer = diffView.Viewer.RightView.BufferGraph.GetTextBuffers(t => t.ContentType.IsOfType(ContentTypeNames.CSharpContentType)).First(); var rightProvider = new DiagnosticsSquiggleTaggerProvider(diagnosticService, foregroundService, listeners); var rightTagger = rightProvider.CreateTagger <IErrorTag>(rightBuffer); using (var rightDisposable = rightTagger as IDisposable) { // wait up to 20 seconds for diagnostics taskSource.Task.Wait(20000); if (!taskSource.Task.IsCompleted) { // something is wrong FatalError.Report(new System.Exception("not finished after 20 seconds")); } // wait taggers await waiter.CreateWaitTask(); // check left buffer var leftSnapshot = leftBuffer.CurrentSnapshot; var leftSpans = leftTagger.GetTags(leftSnapshot.GetSnapshotSpanCollection()).ToList(); Assert.Equal(1, leftSpans.Count); // check right buffer var rightSnapshot = rightBuffer.CurrentSnapshot; var rightSpans = rightTagger.GetTags(rightSnapshot.GetSnapshotSpanCollection()).ToList(); Assert.Equal(0, rightSpans.Count); } } } } }
public async Task LargeNumberOfSpans() { using (var workspace = TestWorkspace.CreateCSharp(@"class Program { void M() { int z = 0; z = z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z + z; } }")) { Callback tagProducer = (span, cancellationToken) => { return(new List <ITagSpan <TestTag> >() { new TagSpan <TestTag>(span, new TestTag()) }); }; var asyncListener = new TaggerOperationListener(); WpfTestCase.RequireWpfFact($"{nameof(AsynchronousTaggerTests)}.{nameof(LargeNumberOfSpans)} creates asynchronous taggers"); var notificationService = workspace.GetService <IForegroundNotificationService>(); var eventSource = CreateEventSource(); var taggerProvider = new TestTaggerProvider( tagProducer, eventSource, workspace, asyncListener, notificationService); var document = workspace.Documents.First(); var textBuffer = document.TextBuffer; var snapshot = textBuffer.CurrentSnapshot; var tagger = taggerProvider.CreateTagger <TestTag>(textBuffer); using (IDisposable disposable = (IDisposable)tagger) { var spans = Enumerable.Range(0, 101).Select(i => new Span(i * 4, 1)); var snapshotSpans = new NormalizedSnapshotSpanCollection(snapshot, spans); eventSource.SendUpdateEvent(); await asyncListener.CreateWaitTask(); var tags = tagger.GetTags(snapshotSpans); Assert.Equal(1, tags.Count()); } } }
public OptionViewModelTests() { WpfTestCase.RequireWpfFact("Tests create WPF ViewModels and updates previews with them"); }