private async Task InsertText(string code, string text, bool expectDocumentAnalysis, string language = LanguageNames.CSharp) { using (var workspace = await TestWorkspace.CreateAsync( SolutionCrawler, language, compilationOptions: null, parseOptions: null, content: code)) { var analyzer = new Analyzer(); var lazyWorker = new Lazy <IIncrementalAnalyzerProvider, IncrementalAnalyzerProviderMetadata>(() => new AnalyzerProvider(analyzer), Metadata.Crawler); var service = new SolutionCrawlerRegistrationService(new[] { lazyWorker }, GetListeners(workspace.ExportProvider)); service.Register(workspace); var testDocument = workspace.Documents.First(); var insertPosition = testDocument.CursorPosition; var textBuffer = testDocument.GetTextBuffer(); using (var edit = textBuffer.CreateEdit()) { edit.Insert(insertPosition.Value, text); edit.Apply(); } await WaitAsync(service, workspace); service.Unregister(workspace); Assert.Equal(1, analyzer.SyntaxDocumentIds.Count); Assert.Equal(expectDocumentAnalysis ? 1 : 0, analyzer.DocumentIds.Count); } }
protected async Task AssertNavigatedAsync(string code, bool next, SourceCodeKind?sourceCodeKind = null) { var kinds = sourceCodeKind != null ? SpecializedCollections.SingletonEnumerable(sourceCodeKind.Value) : new[] { SourceCodeKind.Regular, SourceCodeKind.Script }; foreach (var kind in kinds) { using (var workspace = await TestWorkspace.CreateAsync( LanguageName, compilationOptions: null, parseOptions: DefaultParseOptions.WithKind(kind), content: code)) { var hostDocument = workspace.DocumentWithCursor; var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); Assert.Empty((await document.GetSyntaxTreeAsync()).GetDiagnostics()); var targetPosition = await GoToAdjacentMemberCommandHandler.GetTargetPositionAsync( document, hostDocument.CursorPosition.Value, next, CancellationToken.None); Assert.NotNull(targetPosition); Assert.Equal(hostDocument.SelectedSpans.Single().Start, targetPosition.Value); } } }
public async Task ExtractInterfaceCommandDisabledInSubmission() { var exportProvider = MinimalTestExportProvider.CreateExportProvider( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService))); using (var workspace = await TestWorkspace.CreateAsync(XElement.Parse(@" <Workspace> <Submission Language=""C#"" CommonReferences=""true""> public class $$C { public void M() { } } </Submission> </Workspace> "), workspaceKind: WorkspaceKind.Interactive, exportProvider: exportProvider)) { // Force initialization. workspace.GetOpenDocumentIds().Select(id => workspace.GetTestDocument(id).GetTextView()).ToList(); var textView = workspace.Documents.Single().GetTextView(); var handler = new ExtractInterfaceCommandHandler(); var delegatedToNext = false; Func <CommandState> nextHandler = () => { delegatedToNext = true; return(CommandState.Unavailable); }; var state = handler.GetCommandState(new Commands.ExtractInterfaceCommandArgs(textView, textView.TextBuffer), nextHandler); Assert.True(delegatedToNext); Assert.False(state.IsAvailable); } }
protected async Task TestAsync( string initialMarkup, string expectedMarkup, ParseOptions parseOptions, CompilationOptions compilationOptions, int index = 0, bool compareTokens = true, IDictionary <OptionKey, object> options = null, string fixAllActionEquivalenceKey = null) { string expected; IDictionary <string, IList <TextSpan> > spanMap; MarkupTestFile.GetSpans(expectedMarkup.NormalizeLineEndings(), out expected, out spanMap); var conflictSpans = spanMap.GetOrAdd("Conflict", _ => new List <TextSpan>()); var renameSpans = spanMap.GetOrAdd("Rename", _ => new List <TextSpan>()); var warningSpans = spanMap.GetOrAdd("Warning", _ => new List <TextSpan>()); using (var workspace = IsWorkspaceElement(initialMarkup) ? await TestWorkspace.CreateAsync(initialMarkup) : await CreateWorkspaceFromFileAsync(initialMarkup, parseOptions, compilationOptions)) { ApplyOptionsToWorkspace(workspace, options); var actions = await GetCodeActionsAsync(workspace, fixAllActionEquivalenceKey); await TestActionsAsync( workspace, expected, index, actions, conflictSpans, renameSpans, warningSpans, compareTokens : compareTokens); } }
public async Task ErrorTagGeneratedForWarningAsError() { var workspaceXml = @"<Workspace> <Project Language=""C#"" CommonReferences=""true""> <CompilationOptions ReportDiagnostic = ""Error"" /> <Document FilePath = ""Test.cs"" > class Program { void Test() { int a = 5; } } </Document> </Project> </Workspace>"; using (var workspace = await TestWorkspace.CreateAsync(workspaceXml)) { var spans = (await GetDiagnosticsAndErrorSpans(workspace)).Item2; Assert.Equal(1, spans.Count()); Assert.Equal(PredefinedErrorTypeNames.SyntaxError, spans.First().Tag.ErrorType); } }
protected async Task <TestWorkspace> SetupWorkspaceAsync(XElement workspaceElement) { var workspace = await TestWorkspace.CreateAsync(workspaceElement, exportProvider : s_exportProvider); InitializeWorkspace(workspace); return(workspace); }
protected async Task VerifyItemWithReferenceWorkerAsync(string xmlString, IEnumerable <SignatureHelpTestItem> expectedOrderedItems, bool hideAdvancedMembers) { using (var testWorkspace = await TestWorkspace.CreateAsync(xmlString)) { var optionsService = testWorkspace.Services.GetService <IOptionService>(); var cursorPosition = testWorkspace.Documents.First(d => d.Name == "SourceDocument").CursorPosition.Value; var documentId = testWorkspace.Documents.First(d => d.Name == "SourceDocument").Id; var document = testWorkspace.CurrentSolution.GetDocument(documentId); var code = (await document.GetTextAsync()).ToString(); optionsService.SetOptions(optionsService.GetOptions().WithChangedOption(Microsoft.CodeAnalysis.Completion.CompletionOptions.HideAdvancedMembers, document.Project.Language, hideAdvancedMembers)); IList <TextSpan> textSpans = null; var selectedSpans = testWorkspace.Documents.First(d => d.Name == "SourceDocument").SelectedSpans; if (selectedSpans.Any()) { textSpans = selectedSpans; } TextSpan?textSpan = null; if (textSpans != null && textSpans.Any()) { textSpan = textSpans.First(); } await TestSignatureHelpWorkerSharedAsync(code, cursorPosition, SourceCodeKind.Regular, document, textSpan, expectedOrderedItems); } }
public async Task LiveErrorZeroLengthSpan() { var workspaceXml = @"<Workspace> <Project Language=""C#"" CommonReferences=""true""> <Document FilePath = ""Test.cs"" > class Test { } </Document> </Project> </Workspace>"; using (var workspace = await TestWorkspace.CreateAsync(workspaceXml)) { var document = workspace.Documents.First(); var updateArgs = DiagnosticsUpdatedArgs.DiagnosticsCreated( new LiveId(), workspace, workspace.CurrentSolution, document.Project.Id, document.Id, ImmutableArray.Create( CreateDiagnosticData(workspace, document, new TextSpan(0, 0)), CreateDiagnosticData(workspace, document, new TextSpan(0, 1)))); var spans = await GetErrorsFromUpdateSource(workspace, document, updateArgs); Assert.Equal(2, spans.Count()); var first = spans.First(); var second = spans.Last(); Assert.Equal(1, first.Span.Span.Length); Assert.Equal(1, second.Span.Span.Length); } }
public static async Task <CallHierarchyTestState> CreateAsync(XElement markup, params Type[] additionalTypes) { var exportProvider = CreateExportProvider(additionalTypes); var workspace = await TestWorkspace.CreateAsync(markup, exportProvider : exportProvider); return(new CallHierarchyTestState(workspace)); }
protected async Task VerifyItemInLinkedFilesAsync(string xmlString, string expectedItem, string expectedDescription) { using (var testWorkspace = await TestWorkspace.CreateAsync(xmlString)) { var optionsService = testWorkspace.Services.GetService <IOptionService>(); var position = testWorkspace.Documents.First().CursorPosition.Value; var solution = testWorkspace.CurrentSolution; var textContainer = testWorkspace.Documents.First().TextBuffer.AsTextContainer(); var currentContextDocumentId = testWorkspace.GetDocumentIdInCurrentContext(textContainer); var document = solution.GetDocument(currentContextDocumentId); var triggerInfo = CompletionTrigger.Default; var completionList = await GetCompletionListAsync(document, position, triggerInfo); var completionService = document.Project.LanguageServices.GetService <CompletionService>(); var item = completionList.Items.Single(c => c.DisplayText == expectedItem); Assert.NotNull(item); if (expectedDescription != null) { var actualDescription = (await completionService.GetDescriptionAsync(document, item)).Text; Assert.Equal(expectedDescription, actualDescription); } } }
protected static async Task RunCountTest(XElement input, int cap = 0) { using (var workspace = await TestWorkspace.CreateAsync(input)) { foreach (var annotatedDocument in workspace.Documents.Where(d => d.AnnotatedSpans.Any())) { var document = workspace.CurrentSolution.GetDocument(annotatedDocument.Id); var syntaxNode = await document.GetSyntaxRootAsync(); foreach (var annotatedSpan in annotatedDocument.AnnotatedSpans) { var isCapped = annotatedSpan.Key.StartsWith("capped"); var expected = int.Parse(annotatedSpan.Key.Substring(isCapped ? 6 : 0)); foreach (var span in annotatedSpan.Value) { var declarationSyntaxNode = syntaxNode.FindNode(span); var result = await new CodeLensReferencesService().GetReferenceCountAsync(workspace.CurrentSolution, annotatedDocument.Id, declarationSyntaxNode, cap, CancellationToken.None); Assert.NotNull(result); Assert.Equal(expected, result.Count); Assert.Equal(isCapped, result.IsCapped); } } } } }
private async Task TestAsync( string initialMarkup, string expectedMarkup, ParseOptions parseOptions, CompilationOptions compilationOptions, int index, bool compareTokens, IDictionary <OptionKey, object> options, string fixAllActionEquivalenceKey, object fixProviderData, CodeActionPriority?priority) { MarkupTestFile.GetSpans(expectedMarkup.NormalizeLineEndings(), out var expected, out IDictionary <string, IList <TextSpan> > spanMap); var conflictSpans = spanMap.GetOrAdd("Conflict", _ => new List <TextSpan>()); var renameSpans = spanMap.GetOrAdd("Rename", _ => new List <TextSpan>()); var warningSpans = spanMap.GetOrAdd("Warning", _ => new List <TextSpan>()); using (var workspace = IsWorkspaceElement(initialMarkup) ? await TestWorkspace.CreateAsync(initialMarkup) : await CreateWorkspaceFromFileAsync(initialMarkup, parseOptions, compilationOptions)) { workspace.ApplyOptions(options); var actions = await GetCodeActionsAsync(workspace, fixAllActionEquivalenceKey, fixProviderData); await TestActionsAsync( workspace, expected, index, actions, conflictSpans, renameSpans, warningSpans, compareTokens : compareTokens, parseOptions : parseOptions, priority : priority); } }
public async Task CrefCompletionSpeculatesOutsideTrivia() { var text = @" /// <see cref=""$$ class C { }"; using (var workspace = await TestWorkspace.CreateAsync(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text })) { var called = false; var provider = new CrefCompletionProvider(testSpeculativeNodeCallbackOpt: n => { // asserts that we aren't be asked speculate on nodes inside documentation trivia. // This verifies that the provider is asking for a speculative SemanticModel // by walking to the node the documentation is attached to. called = true; var parent = n.GetAncestor <DocumentationCommentTriviaSyntax>(); Assert.Null(parent); }); var hostDocument = workspace.DocumentWithCursor; var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); var service = CreateCompletionService(workspace, ImmutableArray.Create <CompletionProvider>(provider)); var completionList = await GetCompletionListAsync(service, document, hostDocument.CursorPosition.Value, CompletionTrigger.Invoke); Assert.True(called); } }
protected static async Task RunMethodReferenceTest(XElement input) { using (var workspace = await TestWorkspace.CreateAsync(input)) { foreach (var annotatedDocument in workspace.Documents.Where(d => d.AnnotatedSpans.Any())) { var document = workspace.CurrentSolution.GetDocument(annotatedDocument.Id); var syntaxNode = await document.GetSyntaxRootAsync(); foreach (var annotatedSpan in annotatedDocument.AnnotatedSpans) { var expected = int.Parse(annotatedSpan.Key); foreach (var span in annotatedSpan.Value) { var declarationSyntaxNode = syntaxNode.FindNode(span); var result = await new CodeLensReferencesService().FindReferenceMethodsAsync(workspace.CurrentSolution, annotatedDocument.Id, declarationSyntaxNode, CancellationToken.None); var count = result.Count(); Assert.Equal(expected, count); } } } } }
private static Task <TestWorkspace> CreateTestWorkspaceAsync(string code, string languageName, ExportProvider exportProvider = null) { var xml = string.Format(@" <Workspace> <Project Language=""{0}"" CommonReferences=""true""> <Document>{1}</Document> </Project> </Workspace>", languageName, code); return(TestWorkspace.CreateAsync(xml, exportProvider: exportProvider)); }
protected async Task <TestWorkspace> CreateWorkspaceFromOptionsAsync( string initialMarkup, TestParameters parameters) { var workspace = TestWorkspace.IsWorkspaceElement(initialMarkup) ? await TestWorkspace.CreateAsync(initialMarkup) : await CreateWorkspaceFromFileAsync(initialMarkup, parameters); workspace.ApplyOptions(parameters.options); return(workspace); }
public static async Task <RenameTrackingTestState> CreateFromWorkspaceXmlAsync( string workspaceXml, string languageName, bool onBeforeGlobalSymbolRenamedReturnValue = true, bool onAfterGlobalSymbolRenamedReturnValue = true) { var workspace = await TestWorkspace.CreateAsync( workspaceXml, exportProvider : TestExportProvider.CreateExportProviderWithCSharpAndVisualBasic()); return(new RenameTrackingTestState(workspace, languageName, onBeforeGlobalSymbolRenamedReturnValue, onAfterGlobalSymbolRenamedReturnValue)); }
public static async Task <RenameTrackingTestState> CreateFromWorkspaceXmlAsync( string workspaceXml, string languageName, bool onBeforeGlobalSymbolRenamedReturnValue = true, bool onAfterGlobalSymbolRenamedReturnValue = true) { var workspace = await TestWorkspace.CreateAsync( workspaceXml, exportProvider : EditorServicesUtil.CreateExportProvider()); return(new RenameTrackingTestState(workspace, languageName, onBeforeGlobalSymbolRenamedReturnValue, onAfterGlobalSymbolRenamedReturnValue)); }
protected async Task VerifyNoRegionsAsync(string markupCode) { using (var workspace = await TestWorkspace.CreateAsync(WorkspaceKind, LanguageName, compilationOptions: null, parseOptions: null, content: markupCode)) { var hostDocument = workspace.Documents.Single(); Assert.True(hostDocument.CursorPosition.HasValue, "Test must specify a position."); var position = hostDocument.CursorPosition.Value; var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); var actualRegions = await GetRegionsAsync(document, position); Assert.True(actualRegions.Length == 0, $"Expected no regions but found {actualRegions.Length}."); } }
public static async Task <GenerateTypeTestState> CreateAsync( string initial, string projectToBeModified, string typeName, string existingFileName, string languageName) { var workspace = TestWorkspace.IsWorkspaceElement(initial) ? await TestWorkspace.CreateAsync(initial, exportProvider : s_exportProvider) : languageName == LanguageNames.CSharp ? await TestWorkspace.CreateCSharpAsync(initial, exportProvider : s_exportProvider) : await TestWorkspace.CreateVisualBasicAsync(initial, exportProvider : s_exportProvider); return(new GenerateTypeTestState(projectToBeModified, typeName, existingFileName, workspace)); }
public async Task TestCodeActionPreviewAndApply() { using (var workspace = await TestWorkspace.CreateAsync(WorkspaceXml)) { var codeIssueOrRefactoring = await GetCodeRefactoringAsync(workspace, new TestParameters()); var expectedCode = "private class D { }"; await TestActionsOnLinkedFiles( workspace, expectedText : expectedCode, index : 0, actions : codeIssueOrRefactoring.Actions.ToList(), expectedPreviewContents : expectedCode); } }
private async Task VerifyItemWithMscorlib45WorkerAsync(string xmlString, string expectedItem, string expectedDescription) { using (var testWorkspace = await TestWorkspace.CreateAsync(xmlString)) { var position = testWorkspace.Documents.Single(d => d.Name == "SourceDocument").CursorPosition.Value; var solution = testWorkspace.CurrentSolution; var documentId = testWorkspace.Documents.Single(d => d.Name == "SourceDocument").Id; var document = solution.GetDocument(documentId); var triggerInfo = new CompletionTriggerInfo(); var completionList = await GetCompletionListAsync(document, position, triggerInfo); var item = completionList.Items.FirstOrDefault(i => i.DisplayText == expectedItem); Assert.Equal(expectedDescription, (await item.GetDescriptionAsync()).GetFullText()); } }
public async Task NavigateToGeneratedFiles() { using (var workspace = await TestWorkspace.CreateAsync(@" <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); } }
private async Task TestAddDocument( string initialMarkup, string expectedMarkup, int index, IList <string> expectedContainers, string expectedDocumentName, ParseOptions parseOptions, CompilationOptions compilationOptions, bool compareTokens, bool isLine) { using (var workspace = isLine ? await CreateWorkspaceFromFileAsync(initialMarkup, parseOptions, compilationOptions) : await TestWorkspace.CreateAsync(initialMarkup)) { var codeActions = await GetCodeActionsAsync(workspace, fixAllActionEquivalenceKey : null); await TestAddDocument(workspace, expectedMarkup, index, expectedContainers, expectedDocumentName, codeActions, compareTokens); } }
private async Task VerifyItemWithReferenceWorkerAsync(string xmlString, string expectedItem, int expectedSymbols, bool hideAdvancedMembers) { using (var testWorkspace = await TestWorkspace.CreateAsync(xmlString)) { var optionsService = testWorkspace.Services.GetService <IOptionService>(); var position = testWorkspace.Documents.Single(d => d.Name == "SourceDocument").CursorPosition.Value; var solution = testWorkspace.CurrentSolution; var documentId = testWorkspace.Documents.Single(d => d.Name == "SourceDocument").Id; var document = solution.GetDocument(documentId); optionsService.SetOptions(optionsService.GetOptions().WithChangedOption(CompletionOptions.HideAdvancedMembers, document.Project.Language, hideAdvancedMembers)); var triggerInfo = CompletionTrigger.Default; var completionList = await GetCompletionListAsync(document, position, triggerInfo); var completionService = document.Project.LanguageServices.GetService <CompletionService>(); if (expectedSymbols >= 1) { AssertEx.Any(completionList.Items, c => CompareItems(c.DisplayText, expectedItem)); // Throw if multiple to indicate a bad test case var item = completionList.Items.Single(c => CompareItems(c.DisplayText, expectedItem)); var description = await completionService.GetDescriptionAsync(document, item); if (expectedSymbols == 1) { Assert.DoesNotContain("+", description.Text, StringComparison.Ordinal); } else { Assert.Contains(GetExpectedOverloadSubstring(expectedSymbols), description.Text, StringComparison.Ordinal); } } else { if (completionList != null) { AssertEx.None(completionList.Items, c => CompareItems(c.DisplayText, expectedItem)); } } } }
protected async Task <int?> GetTargetPositionAsync(string code, bool next) { using (var workspace = await TestWorkspace.CreateAsync( LanguageName, compilationOptions: null, parseOptions: DefaultParseOptions, content: code)) { var hostDocument = workspace.DocumentWithCursor; var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); Assert.Empty((await document.GetSyntaxTreeAsync()).GetDiagnostics()); return(await GoToAdjacentMemberCommandHandler.GetTargetPositionAsync( document, hostDocument.CursorPosition.Value, next, CancellationToken.None)); } }
public async void TestResetREPLWithProjectContext() { using (var workspace = await TestWorkspace.CreateAsync(WorkspaceXmlStr)) { var project = workspace.CurrentSolution.Projects.FirstOrDefault(p => p.AssemblyName == "ResetInteractiveTestsAssembly"); var document = project.Documents.FirstOrDefault(d => d.FilePath == "ResetInteractiveTestsDocument"); var replReferenceCommands = GetProjectReferences(workspace, project).Select(r => CreateReplReferenceCommand(r)); Assert.True(replReferenceCommands.Any(rc => rc.EndsWith(@"ResetInteractiveTestsAssembly.dll"""))); Assert.True(replReferenceCommands.Any(rc => rc.EndsWith(@"ResetInteractiveVisualBasicSubproject.dll"""))); var expectedSubmissions = new List <string> { string.Join("\r\n", replReferenceCommands) + "\r\n", string.Join("\r\n", @"using ""ns1"";", @"using ""ns2"";") + "\r\n" }; AssertResetInteractive(workspace, project, buildSucceeds: true, expectedSubmissions: expectedSubmissions); // Test that no submissions are executed if the build fails. AssertResetInteractive(workspace, project, buildSucceeds: false, expectedSubmissions: new List <string>()); } }
protected async Task VerifyRegionsAsync(string markupCode, params Tuple <string, string, string, bool, bool>[] expectedRegionData) { using (var workspace = await TestWorkspace.CreateAsync(WorkspaceKind, LanguageName, compilationOptions: null, parseOptions: null, content: markupCode)) { var hostDocument = workspace.Documents.Single(); Assert.True(hostDocument.CursorPosition.HasValue, "Test must specify a position."); var position = hostDocument.CursorPosition.Value; var expectedRegions = expectedRegionData.Select(data => CreateOutliningSpan(data, hostDocument.AnnotatedSpans)).ToArray(); var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); var actualRegions = await GetRegionsAsync(document, position); Assert.True(expectedRegions.Length == actualRegions.Length, $"Expected {expectedRegions.Length} regions but there were {actualRegions.Length}"); for (int i = 0; i < expectedRegions.Length; i++) { AssertRegion(expectedRegions[i], actualRegions[i]); } } }
public async Task CrefCompletionSpeculatesOutsideTrivia() { var text = @" /// <see cref=""$$ class C { }"; var exportProvider = MinimalTestExportProvider.CreateExportProvider(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(PickySemanticFactsService))); using (var workspace = await TestWorkspace.CreateAsync(LanguageNames.CSharp, new CSharpCompilationOptions(OutputKind.ConsoleApplication), new CSharpParseOptions(), new[] { text }, exportProvider)) { // This test uses MEF to compose in an ISyntaxFactsService that // asserts it isn't asked to speculate on nodes inside documentation trivia. // This verifies that the provider is asking for a speculative SemanticModel // by walking to the node the documentation is attached to. var provider = new CrefCompletionProvider(); var hostDocument = workspace.DocumentWithCursor; var document = workspace.CurrentSolution.GetDocument(hostDocument.Id); var completionList = await GetCompletionListAsync(provider, document, hostDocument.CursorPosition.Value, CompletionTriggerInfo.CreateInvokeCompletionTriggerInfo()); } }
private static Task <TestWorkspace> CreateWorkspaceAsync(string projectLanguage, IEnumerable <string> metadataSources, bool includeXmlDocComments, string sourceWithSymbolReference) { var xmlString = string.Concat(@" <Workspace> <Project Language=""", projectLanguage, @""" CommonReferences=""true"">"); metadataSources = metadataSources ?? new[] { AbstractMetadataAsSourceTests.DefaultMetadataSource }; foreach (var source in metadataSources) { var metadataLanguage = DeduceLanguageString(source); xmlString = string.Concat(xmlString, string.Format(@" <MetadataReferenceFromSource Language=""{0}"" CommonReferences=""true"" IncludeXmlDocComments=""{2}""> <Document FilePath=""MetadataDocument""> {1} </Document> </MetadataReferenceFromSource>", metadataLanguage, SecurityElement.Escape(source), includeXmlDocComments.ToString())); } if (sourceWithSymbolReference != null) { xmlString = string.Concat(xmlString, string.Format(@" <Document FilePath=""SourceDocument""> {0} </Document>", sourceWithSymbolReference)); } xmlString = string.Concat(xmlString, @" </Project> </Workspace>"); return(TestWorkspace.CreateAsync(xmlString)); }