public async Task AnalyzeDocumentAsync_Features_Change()
{
// these are all the experimental features currently implemented
string[] experimentalFeatures = Array.Empty <string>();
foreach (var feature in experimentalFeatures)
{
string source1 = @"
class C
{
public static void Main()
{
System.Console.WriteLine(1);
}
}
";
string source2 = @"
class C
{
public static void Main()
{
System.Console.WriteLine(2);
}
}
";
var analyzer = new CSharpEditAndContinueAnalyzer();
var featuresToEnable = new Dictionary <string, string>()
{
{ feature, "enabled" }
};
var experimental = TestOptions.Regular.WithFeatures(featuresToEnable);
using (var workspace = await TestWorkspace.CreateCSharpAsync(
source1, parseOptions: experimental, compilationOptions: null, exportProvider: null))
{
var documentId = workspace.CurrentSolution.Projects.First().Documents.First().Id;
var oldSolution = workspace.CurrentSolution;
var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
var baseActiveStatements = ImmutableArray.Create <ActiveStatementSpan>();
var result = await analyzer.AnalyzeDocumentAsync(oldSolution, baseActiveStatements, newSolution.GetDocument(documentId), default(CancellationToken));
Assert.True(result.HasChanges);
Assert.True(result.HasChangesAndErrors);
Assert.False(result.HasChangesAndCompilationErrors);
Assert.Equal(RudeEditKind.ExperimentalFeaturesEnabled, result.RudeEditErrors.Single().Kind);
}
}
}
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 async Task TestOptionLoading()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(""))
{
var optionSet = workspace.Options.WithChangedOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName, true);
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(optionSet, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType <CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
Assert.True(checkbox.IsChecked);
}
}
}
private async Task TestAsync(string markup, string expectedName, int expectedLineOffset, CSharpParseOptions parseOptions = null)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(markup, parseOptions))
{
var testDocument = workspace.Documents.Single();
var position = testDocument.CursorPosition.Value;
var locationInfo = await LocationInfoGetter.GetInfoAsync(
workspace.CurrentSolution.Projects.Single().Documents.Single(),
position,
CancellationToken.None);
Assert.Equal(expectedName, locationInfo.Name);
Assert.Equal(expectedLineOffset, locationInfo.LineOffset);
}
}
private async Task AssertSmartTokenFormatterOpenBraceAsync(
string expected,
string code,
int indentationLine)
{
// create tree service
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var buffer = workspace.Documents.First().GetTextBuffer();
var actual = await TokenFormatAsync(workspace, buffer, indentationLine, '{');
Assert.Equal(expected, actual);
}
}
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));
}
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 VerifyRefactoringDisabledAsync(CodeRefactoringProvider codeRefactoring)
{
var refactoringService = new CodeRefactorings.CodeRefactoringService(GetMetadata(codeRefactoring));
using (var workspace = await TestWorkspace.CreateCSharpAsync(@"class Program {}"))
{
var project = workspace.CurrentSolution.Projects.Single();
var document = project.Documents.Single();
var extensionManager = document.Project.Solution.Workspace.Services.GetService <IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager;
var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None);
Assert.True(extensionManager.IsDisabled(codeRefactoring));
Assert.False(extensionManager.IsIgnored(codeRefactoring));
}
}
public async Task AnalyzeDocumentAsync_AddingNewFile()
{
string source1 = @"
namespace N
{
class C
{
public static void Main()
{
}
}
}
";
string source2 = @"
";
var analyzer = new CSharpEditAndContinueAnalyzer();
using (var workspace = await TestWorkspace.CreateCSharpAsync(source1))
{
// fork the solution to introduce a change
var project = workspace.CurrentSolution.Projects.Single();
var newDocId = DocumentId.CreateNewId(project.Id);
var oldSolution = workspace.CurrentSolution;
var newSolution = oldSolution.AddDocument(newDocId, "foo.cs", SourceText.From(source2));
workspace.TryApplyChanges(newSolution);
var newProject = newSolution.Projects.Single();
var changes = newProject.GetChanges(project);
Assert.Equal(2, newProject.Documents.Count());
Assert.Equal(0, changes.GetChangedDocuments().Count());
Assert.Equal(1, changes.GetAddedDocuments().Count());
var changedDocuments = changes.GetChangedDocuments().Concat(changes.GetAddedDocuments());
var result = new List <DocumentAnalysisResults>();
var baseActiveStatements = ImmutableArray.Create <ActiveStatementSpan>();
foreach (var changedDocumentId in changedDocuments)
{
result.Add(await analyzer.AnalyzeDocumentAsync(oldSolution, baseActiveStatements, newProject.GetDocument(changedDocumentId), default(CancellationToken)));
}
Assert.True(result.IsSingle());
Assert.Equal(1, result.Single().RudeEditErrors.Count());
Assert.Equal(RudeEditKind.InsertFile, result.Single().RudeEditErrors.Single().Kind);
}
}
public async Task AnalyzerCreatedAtCompilationLevelNeedNotBeCompilationAnalyzer()
{
var source = @"x";
var analyzer = new CompilationAnalyzerWithSyntaxTreeAnalyzer();
using (var ideEngineWorkspace = await TestWorkspace.CreateCSharpAsync(source))
{
var ideEngineDocument = ideEngineWorkspace.CurrentSolution.Projects.Single().Documents.Single();
var diagnostics = await DiagnosticProviderTestUtilities.GetAllDiagnosticsAsync(analyzer, ideEngineDocument, new Text.TextSpan(0, ideEngineDocument.GetTextAsync().Result.Length));
var diagnosticsFromAnalyzer = diagnostics.Where(d => d.Id == "SyntaxDiagnostic");
Assert.Equal(1, diagnosticsFromAnalyzer.Count());
}
}
private async Task TestSpanGetterAsync(string markup, Func <Document, int, TextSpan?, Task> continuation)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(markup))
{
var testHostDocument = workspace.Documents.Single();
var position = testHostDocument.CursorPosition.Value;
var expectedSpan = testHostDocument.SelectedSpans.Any()
? testHostDocument.SelectedSpans.Single()
: (TextSpan?)null;
await continuation(
workspace.CurrentSolution.Projects.First().Documents.First(),
position,
expectedSpan);
}
}
public async Task TestCreation()
{
var code = @"class Test { void Method() { } }";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var solution = workspace.CurrentSolution;
var service = await GetSolutionServiceAsync(solution);
var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
var synched = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
Assert.Equal(solutionChecksum, await synched.State.GetChecksumAsync(CancellationToken.None));
}
}
public async Task TestOptionSaving()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(""))
{
var serviceProvider = new MockServiceProvider(workspace.ExportProvider);
using (var viewModel = new SpacingViewModel(workspace.Options, serviceProvider))
{
// Use the first item's preview.
var checkbox = viewModel.Items.OfType <CheckBoxOptionViewModel>().Where(c => c.Option == CSharpFormattingOptions.SpacingAfterMethodDeclarationName).First();
var initial = checkbox.IsChecked;
checkbox.IsChecked = !checkbox.IsChecked;
var changedOptions = viewModel.ApplyChangedOptions(workspace.Options);
Assert.NotEqual(changedOptions.GetOption(CSharpFormattingOptions.SpacingAfterMethodDeclarationName), initial);
}
}
}
protected async Task ExpectExtractMethodToFailAsync(string codeWithMarker, bool allowMovingDeclaration = true, bool dontPutOutOrRefOnStruct = true, string[] features = null)
{
ParseOptions parseOptions = null;
if (features != null)
{
var featuresMapped = features.Select(x => new KeyValuePair <string, string>(x, string.Empty));
parseOptions = new CSharpParseOptions().WithFeatures(featuresMapped);
}
using (var workspace = await TestWorkspace.CreateCSharpAsync(codeWithMarker, parseOptions: parseOptions))
{
var testDocument = workspace.Documents.First();
var textSpan = testDocument.SelectedSpans.Single();
var treeAfterExtractMethod = await ExtractMethodAsync(workspace, testDocument, succeed : false, allowMovingDeclaration : allowMovingDeclaration, dontPutOutOrRefOnStruct : dontPutOutOrRefOnStruct);
}
}
private async Task TestProximityExpressionGetterAsync(
string markup,
Func <CSharpProximityExpressionsService, Document, int, Task> continuation)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(markup))
{
var testDocument = workspace.Documents.Single();
var caretPosition = testDocument.CursorPosition.Value;
var snapshot = testDocument.TextBuffer.CurrentSnapshot;
var languageDebugInfo = new CSharpLanguageDebugInfoService();
var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
var proximityExpressionsGetter = new CSharpProximityExpressionsService();
await continuation(proximityExpressionsGetter, document, caretPosition);
}
}
private async Task VerifyExclusiveAsync(string markup, bool exclusive)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(markup))
{
var hostDocument = workspace.Documents.Single();
var position = hostDocument.CursorPosition.Value;
var document = workspace.CurrentSolution.GetDocument(hostDocument.Id);
var triggerInfo = CompletionTriggerInfo.CreateTypeCharTriggerInfo('a');
var completionList = await GetCompletionListAsync(document, position, triggerInfo);
if (completionList != null)
{
Assert.True(exclusive == completionList.IsExclusive, "group.IsExclusive == " + completionList.IsExclusive);
}
}
}
private static async Task <Tuple <TestWorkspace, TestDiagnosticAnalyzerService, CodeFixService, IErrorLoggerService> > ServiceSetupAsync(CodeFixProvider codefix)
{
var diagnosticService = new TestDiagnosticAnalyzerService(DiagnosticExtensions.GetCompilerDiagnosticAnalyzersMap());
var fixers = SpecializedCollections.SingletonEnumerable(
new Lazy <CodeFixProvider, CodeChangeProviderMetadata>(
() => codefix,
new CodeChangeProviderMetadata("Test", languages: LanguageNames.CSharp)));
var code = @"class Program { }";
var workspace = await TestWorkspace.CreateCSharpAsync(code);
var logger = SpecializedCollections.SingletonEnumerable(new Lazy <IErrorLoggerService>(() => new TestErrorLogger()));
var errorLogger = logger.First().Value;
var fixService = new CodeFixService(
diagnosticService, logger, fixers, SpecializedCollections.EmptyEnumerable <Lazy <ISuppressionFixProvider, CodeChangeProviderMetadata> >());
return(Tuple.Create(workspace, diagnosticService, fixService, errorLogger));
}
protected static async Task AssertFormatWithPasteOrReturnAsync(string expectedWithMarker, string codeWithMarker, bool allowDocumentChanges, bool isPaste = true)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(codeWithMarker))
{
workspace.CanApplyChangeDocument = allowDocumentChanges;
// set up caret position
var testDocument = workspace.Documents.Single();
var view = testDocument.GetTextView();
view.Caret.MoveTo(new SnapshotPoint(view.TextSnapshot, testDocument.CursorPosition.Value));
// get original buffer
var buffer = workspace.Documents.First().GetTextBuffer();
var optionService = workspace.Services.GetService <IOptionService>();
if (isPaste)
{
optionService.SetOptions(optionService.GetOptions().WithChangedOption(FeatureOnOffOptions.FormatOnPaste, LanguageNames.CSharp, true));
var commandHandler = new FormatCommandHandler(TestWaitIndicator.Default, null, null);
var commandArgs = new PasteCommandArgs(view, view.TextBuffer);
commandHandler.ExecuteCommand(commandArgs, () => { });
}
else
{
// Return Key Command
var textUndoHistory = new Mock <ITextUndoHistoryRegistry>();
var editorOperationsFactory = new Mock <IEditorOperationsFactoryService>();
var editorOperations = new Mock <IEditorOperations>();
editorOperationsFactory.Setup(x => x.GetEditorOperations(testDocument.GetTextView())).Returns(editorOperations.Object);
var commandHandler = new FormatCommandHandler(TestWaitIndicator.Default, textUndoHistory.Object, editorOperationsFactory.Object);
var commandArgs = new ReturnKeyCommandArgs(view, view.TextBuffer);
commandHandler.ExecuteCommand(commandArgs, () => { });
}
string expected;
int expectedPosition;
MarkupTestFile.GetPosition(expectedWithMarker, out expected, out expectedPosition);
Assert.Equal(expected, view.TextSnapshot.GetText());
var caretPosition = view.Caret.Position.BufferPosition.Position;
Assert.True(expectedPosition == caretPosition,
string.Format("Caret positioned incorrectly. Should have been {0}, but was {1}.", expectedPosition, caretPosition));
}
}
private static async Task UncommentSelectionAsync(string markup, string expected)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(markup))
{
var doc = workspace.Documents.First();
SetupSelection(doc.GetTextView(), doc.SelectedSpans.Select(s => Span.FromBounds(s.Start, s.End)));
var commandHandler = new CommentUncommentSelectionCommandHandler(
TestWaitIndicator.Default,
workspace.ExportProvider.GetExportedValue <ITextUndoHistoryRegistry>(),
workspace.ExportProvider.GetExportedValue <IEditorOperationsFactoryService>());
var textView = doc.GetTextView();
var textBuffer = doc.GetTextBuffer();
commandHandler.ExecuteCommand(textView, textBuffer, CommentUncommentSelectionCommandHandler.Operation.Uncomment);
Assert.Equal(expected, doc.TextBuffer.CurrentSnapshot.GetText());
}
}
public async Task TestRemoteWorkspaceSolutionCrawler()
{
var code = @"class Test { void Method() { } }";
// create base solution
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
// create solution service
var solution = workspace.CurrentSolution;
var service = await GetSolutionServiceAsync(solution);
// update primary workspace
var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
await service.UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
// get solution in remote host
var oopSolution = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
Assert.True(oopSolution.Workspace is RemoteWorkspace);
// get solution cralwer in remote host
var solutionCrawlerService = oopSolution.Workspace.Services.GetService <ISolutionCrawlerRegistrationService>() as SolutionCrawlerRegistrationService;
Assert.NotNull(solutionCrawlerService);
// check remote workspace has enabled solution crawler in remote host
var testAnalyzerProvider = new TestAnalyzerProvider();
solutionCrawlerService.AddAnalyzerProvider(
testAnalyzerProvider,
new IncrementalAnalyzerProviderMetadata("Test", highPriorityForActiveFile: false, workspaceKinds: WorkspaceKind.RemoteWorkspace));
// check our solution crawler has ran
Assert.True(await testAnalyzerProvider.Analyzer.Called);
testAnalyzerProvider.Analyzer.Reset();
// update remote workspace
var remoteWorkspace = (RemoteWorkspace)oopSolution.Workspace;
remoteWorkspace.UpdateSolution(oopSolution.WithDocumentText(oopSolution.Projects.First().Documents.First().Id, SourceText.From(code + " class Test2 { }")));
// check solution update correctly ran solution crawler
Assert.True(await testAnalyzerProvider.Analyzer.Called);
}
}
protected async Task AssertFormatAsync(string expected, string code, bool debugMode = false, Dictionary <OptionKey, object> changedOptionSet = null, bool useTab = false, bool testWithTransformation = true)
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var hostdoc = workspace.Documents.First();
// get original buffer
var buffer = hostdoc.GetTextBuffer();
// create new buffer with cloned content
var clonedBuffer = EditorFactory.CreateBuffer(
buffer.ContentType.TypeName,
workspace.ExportProvider,
buffer.CurrentSnapshot.GetText());
var document = workspace.CurrentSolution.GetDocument(hostdoc.Id);
var syntaxTree = await document.GetSyntaxTreeAsync();
var formattingRuleProvider = workspace.Services.GetService <IHostDependentFormattingRuleFactoryService>();
var options = workspace.Options;
if (changedOptionSet != null)
{
foreach (var entry in changedOptionSet)
{
options = options.WithChangedOption(entry.Key, entry.Value);
}
}
options = options.WithChangedOption(FormattingOptions.UseTabs, LanguageNames.CSharp, useTab);
var root = await syntaxTree.GetRootAsync();
var rules = formattingRuleProvider.CreateRule(workspace.CurrentSolution.GetDocument(syntaxTree), 0).Concat(Formatter.GetDefaultFormattingRules(workspace, root.Language));
AssertFormat(workspace, expected, options, rules, clonedBuffer, root);
if (testWithTransformation)
{
// format with node and transform
AssertFormatWithTransformation(workspace, expected, options, rules, root);
}
}
}
public async Task DiagnosticAnalyzerDriverVsAnalyzerDriverOnCodeBlock()
{
var methodNames = new string[] { "Initialize", "AnalyzeCodeBlock" };
var source = @"
[System.Obsolete]
class C
{
int P { get; set; }
delegate void A();
delegate string F();
}
";
var ideEngineAnalyzer = new CSharpTrackingDiagnosticAnalyzer();
using (var ideEngineWorkspace = await TestWorkspace.CreateCSharpAsync(source))
{
var ideEngineDocument = ideEngineWorkspace.CurrentSolution.Projects.Single().Documents.Single();
await DiagnosticProviderTestUtilities.GetAllDiagnosticsAsync(ideEngineAnalyzer, ideEngineDocument, new Text.TextSpan(0, ideEngineDocument.GetTextAsync().Result.Length));
foreach (var method in methodNames)
{
Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid));
Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid));
Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType));
Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property));
}
}
var compilerEngineAnalyzer = new CSharpTrackingDiagnosticAnalyzer();
using (var compilerEngineWorkspace = await TestWorkspace.CreateCSharpAsync(source))
{
var compilerEngineCompilation = (CSharpCompilation)compilerEngineWorkspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result;
compilerEngineCompilation.GetAnalyzerDiagnostics(new[] { compilerEngineAnalyzer });
foreach (var method in methodNames)
{
Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid));
Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid));
Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType));
Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property));
}
}
}
public async Task TestRemoteHostSynchronize()
{
var code = @"class Test { void Method() { } }";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var client = (InProcRemoteHostClient)(await InProcRemoteHostClient.CreateAsync(workspace, runCacheCleanup: false, cancellationToken: CancellationToken.None));
var solution = workspace.CurrentSolution;
await UpdatePrimaryWorkspace(client, solution);
VerifyAssetStorage(client, solution);
Assert.Equal(
await solution.State.GetChecksumAsync(CancellationToken.None),
await PrimaryWorkspace.Workspace.CurrentSolution.State.GetChecksumAsync(CancellationToken.None));
}
}
public async Task CodeBlockAnalyzersOnlyAnalyzeExecutableCode()
{
var source = @"
using System;
class C
{
void F(int x = 0)
{
Console.WriteLine(0);
}
}
";
var analyzer = new CodeBlockAnalyzerFactory();
using (var ideEngineWorkspace = await TestWorkspace.CreateCSharpAsync(source))
{
var ideEngineDocument = ideEngineWorkspace.CurrentSolution.Projects.Single().Documents.Single();
var diagnostics = await DiagnosticProviderTestUtilities.GetAllDiagnosticsAsync(analyzer, ideEngineDocument, new Text.TextSpan(0, ideEngineDocument.GetTextAsync().Result.Length));
var diagnosticsFromAnalyzer = diagnostics.Where(d => d.Id == CodeBlockAnalyzerFactory.Descriptor.Id);
Assert.Equal(2, diagnosticsFromAnalyzer.Count());
}
source = @"
using System;
class C
{
void F(int x = 0, int y = 1, int z = 2)
{
Console.WriteLine(0);
}
}
";
using (var compilerEngineWorkspace = await TestWorkspace.CreateCSharpAsync(source))
{
var compilerEngineCompilation = (CSharpCompilation)compilerEngineWorkspace.CurrentSolution.Projects.Single().GetCompilationAsync().Result;
var diagnostics = compilerEngineCompilation.GetAnalyzerDiagnostics(new[] { analyzer });
var diagnosticsFromAnalyzer = diagnostics.Where(d => d.Id == CodeBlockAnalyzerFactory.Descriptor.Id);
Assert.Equal(4, diagnosticsFromAnalyzer.Count());
}
}
public async Task TestFindReferencesSynchronousCall()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync("class C { C() { new C(); } }"))
{
var findReferencesPresenter = new MockDefinitionsAndReferencesPresenter();
var handler = new FindReferencesCommandHandler(
TestWaitIndicator.Default,
SpecializedCollections.SingletonEnumerable(findReferencesPresenter));
var textView = workspace.Documents[0].GetTextView();
textView.Caret.MoveTo(new SnapshotPoint(textView.TextSnapshot, 7));
handler.ExecuteCommand(new FindReferencesCommandArgs(
textView,
textView.TextBuffer), () => { });
AssertResult(findReferencesPresenter.DefinitionsAndReferences, "C", ".ctor");
}
}
public async Task TestUpdatePrimaryWorkspace()
{
var code = @"class Test { void Method() { } }";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var map = new Dictionary <Checksum, object>();
var solution = workspace.CurrentSolution;
var service = await GetSolutionServiceAsync(solution, map);
var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
// update primary workspace
await service.UpdatePrimaryWorkspaceAsync(solutionChecksum, CancellationToken.None);
var first = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
Assert.Equal(solutionChecksum, await first.State.GetChecksumAsync(CancellationToken.None));
Assert.True(object.ReferenceEquals(PrimaryWorkspace.Workspace.PrimaryBranchId, first.BranchId));
// change content
var newSolution = solution.WithDocumentText(solution.Projects.First().DocumentIds.First(), SourceText.From(code + " "));
var newSolutionChecksum = await newSolution.State.GetChecksumAsync(CancellationToken.None);
newSolution.AppendAssetMap(map);
// get solution without updating primary workspace
var second = await service.GetSolutionAsync(newSolutionChecksum, CancellationToken.None);
Assert.Equal(newSolutionChecksum, await second.State.GetChecksumAsync(CancellationToken.None));
Assert.False(object.ReferenceEquals(PrimaryWorkspace.Workspace.PrimaryBranchId, second.BranchId));
// do same once updating primary workspace
await service.UpdatePrimaryWorkspaceAsync(newSolutionChecksum, CancellationToken.None);
var third = await service.GetSolutionAsync(newSolutionChecksum, CancellationToken.None);
Assert.Equal(newSolutionChecksum, await third.State.GetChecksumAsync(CancellationToken.None));
Assert.True(object.ReferenceEquals(PrimaryWorkspace.Workspace.PrimaryBranchId, third.BranchId));
}
}
public async Task CSharpOutliningTagger_RegionIsDefinition()
{
var code =
@"using System;
namespace MyNamespace
{
#region MyRegion
public class MyClass
{
static void Main(string[] args)
{
int x = 5;
}
}
#endregion
}";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
workspace.Options = workspace.Options.WithChangedOption(
BlockStructureOptions.CollapseRegionsWhenCollapsingToDefinitions, LanguageNames.CSharp, true);
var tags = await GetTagsFromWorkspaceAsync(workspace);
// ensure all 4 outlining region tags were found
Assert.Equal(4, tags.Count);
// ensure the method and #region outlining spans are marked as implementation
Assert.False(tags[0].IsImplementation);
Assert.True(tags[1].IsImplementation);
Assert.False(tags[2].IsImplementation);
Assert.True(tags[3].IsImplementation);
// verify line counts
var hints = tags.Select(x => x.CollapsedHintForm).Cast <ViewHostingControl>().Select(vhc => vhc.TextView_TestOnly).ToList();
Assert.Equal(12, hints[0].TextSnapshot.LineCount); // namespace
Assert.Equal(9, hints[1].TextSnapshot.LineCount); // region
Assert.Equal(7, hints[2].TextSnapshot.LineCount); // class
Assert.Equal(4, hints[3].TextSnapshot.LineCount); // method
hints.Do(v => v.Close());
}
}
public async Task TestPreviewDiagnosticTagger()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync("class { }"))
using (var previewWorkspace = new PreviewWorkspace(workspace.CurrentSolution))
{
//// preview workspace and owner of the solution now share solution and its underlying text buffer
var hostDocument = workspace.Projects.First().Documents.First();
//// enable preview diagnostics
previewWorkspace.EnableDiagnostic();
var diagnosticsAndErrorsSpans = await SquiggleUtilities.GetDiagnosticsAndErrorSpans(workspace);
const string AnalzyerCount = "Analyzer Count: ";
Assert.Equal(AnalzyerCount + 1, AnalzyerCount + diagnosticsAndErrorsSpans.Item1.Length);
const string SquigglesCount = "Squiggles Count: ";
Assert.Equal(SquigglesCount + 1, SquigglesCount + diagnosticsAndErrorsSpans.Item2.Count);
}
}
public async Task AnalyzerOptionsArePassedToAllAnalyzers()
{
using (var workspace = await TestWorkspace.CreateCSharpAsync(TestResource.AllInOneCSharpCode, TestOptions.Regular))
{
var currentProject = workspace.CurrentSolution.Projects.Single();
var additionalDocId = DocumentId.CreateNewId(currentProject.Id);
var newSln = workspace.CurrentSolution.AddAdditionalDocument(additionalDocId, "add.config", SourceText.From("random text"));
currentProject = newSln.Projects.Single();
var additionalDocument = currentProject.GetAdditionalDocument(additionalDocId);
AdditionalText additionalStream = new AdditionalTextDocument(additionalDocument.State);
AnalyzerOptions options = new AnalyzerOptions(ImmutableArray.Create(additionalStream));
var analyzer = new OptionsDiagnosticAnalyzer <SyntaxKind>(expectedOptions: options);
var sourceDocument = currentProject.Documents.Single();
await DiagnosticProviderTestUtilities.GetAllDiagnosticsAsync(analyzer, sourceDocument, new Text.TextSpan(0, sourceDocument.GetTextAsync().Result.Length));
analyzer.VerifyAnalyzerOptions();
}
}
public async Task TestCache()
{
var code = @"class Test { void Method() { } }";
using (var workspace = await TestWorkspace.CreateCSharpAsync(code))
{
var solution = workspace.CurrentSolution;
var service = await GetSolutionServiceAsync(solution);
var solutionChecksum = await solution.State.GetChecksumAsync(CancellationToken.None);
var first = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
var second = await service.GetSolutionAsync(solutionChecksum, CancellationToken.None);
// same instance from cache
Assert.True(object.ReferenceEquals(first, second));
Assert.True(first.Workspace is TemporaryWorkspace);
}
}
