public async Task TestHasSuccessfullyLoadedBeingFalseWhenFileOpened()
{
var workspace = new AdhocWorkspace();
var document = GetDocumentFromIncompleteProject(workspace);
// open document
workspace.OpenDocument(document.Id);
// create listener/service/analyzer
var listener = new AsynchronousOperationListener();
var service = new MyDiagnosticAnalyzerService(new Analyzer(), listener);
var analyzer = service.CreateIncrementalAnalyzer(workspace);
bool syntax = false;
bool semantic = false;
// listen to events
service.DiagnosticsUpdated += (s, a) =>
{
switch (a.Diagnostics.Length)
{
case 0:
return;
case 1:
syntax |= a.Diagnostics[0].Id == Analyzer.s_syntaxRule.Id;
semantic |= a.Diagnostics[0].Id == Analyzer.s_semanticRule.Id;
return;
default:
AssertEx.Fail("shouldn't reach here");
return;
}
};
// now call each analyze method. none of them should run.
await analyzer.AnalyzeSyntaxAsync(document, InvocationReasons.Empty, CancellationToken.None).ConfigureAwait(false);
await analyzer.AnalyzeDocumentAsync(document, bodyOpt: null, reasons: InvocationReasons.Empty, cancellationToken: CancellationToken.None).ConfigureAwait(false);
await analyzer.AnalyzeProjectAsync(document.Project, semanticsChanged: true, reasons: InvocationReasons.Empty, cancellationToken: CancellationToken.None).ConfigureAwait(false);
// wait for all events to raised
await listener.CreateWaitTask().ConfigureAwait(false);
// two should have been called.
Assert.True(syntax);
Assert.True(semantic);
}
public ICodeDocument[] AddDecompiledCode(IDecompiledCodeResult decompiledCodeResult)
{
Debug.Assert(workspace == null);
workspace = new AdhocWorkspace(RoslynMefHostServices.DefaultServices);
workspace.WorkspaceChanged += Workspace_WorkspaceChanged;
var refs = decompiledCodeResult.AssemblyReferences.Select(a => a.CreateMetadataReference(docFactory)).ToArray();
var projectId = ProjectId.CreateNewId();
foreach (var doc in decompiledCodeResult.Documents)
{
documents.Add(CreateDocument(projectId, doc));
}
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "compilecodeproj", decompiledCodeResult.AssemblyName, LanguageName,
compilationOptions: CompilationOptions
.WithOptimizationLevel(OptimizationLevel.Release)
.WithPlatform(GetPlatform(decompiledCodeResult.Platform))
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default),
parseOptions: ParseOptions,
documents: documents.Select(a => a.Info),
metadataReferences: refs,
isSubmission: false, hostObjectType: null);
workspace.AddProject(projectInfo);
foreach (var doc in documents)
{
workspace.OpenDocument(doc.Info.Id);
}
foreach (var doc in documents)
{
if (textViewUndoManagerProvider.TryGetTextViewUndoManager(doc.TextView, out var manager))
{
manager.ClearUndoHistory();
}
}
return(documents.ToArray());
}
public void TestOpenCloseDocument()
{
var pid = ProjectId.CreateNewId();
var text = SourceText.From("public class C { }");
var version = VersionStamp.Create();
var docInfo = DocumentInfo.Create(
DocumentId.CreateNewId(pid),
"c.cs",
loader: TextLoader.From(TextAndVersion.Create(text, version))
);
var projInfo = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp,
documents: new[] { docInfo }
);
using var ws = new AdhocWorkspace();
ws.AddProject(projInfo);
var doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.False(doc.TryGetText(out var currentText));
ws.OpenDocument(docInfo.Id);
doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.True(doc.TryGetText(out currentText));
Assert.True(doc.TryGetTextVersion(out var currentVersion));
Assert.Same(text, currentText);
Assert.Equal(version, currentVersion);
ws.CloseDocument(docInfo.Id);
doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.False(doc.TryGetText(out currentText));
}
public ICodeDocument[] AddDecompiledCode(IDecompiledCodeResult decompiledCodeResult)
{
Debug.Assert(workspace == null);
workspace = new AdhocWorkspace(DesktopMefHostServices.DefaultServices);
var refs = decompiledCodeResult.AssemblyReferences.Select(a => a.CreateMetadataReference()).ToArray();
var projectId = ProjectId.CreateNewId();
foreach (var doc in decompiledCodeResult.Documents)
{
documents.Add(CreateDocument(projectId, doc.NameNoExtension));
}
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Default, "compilecodeproj", Guid.NewGuid().ToString(), LanguageName,
compilationOptions: CompilationOptions.WithOptimizationLevel(OptimizationLevel.Release).WithPlatform(GetPlatform(decompiledCodeResult.Platform)),
parseOptions: ParseOptions,
documents: documents.Select(a => a.Info),
metadataReferences: refs,
isSubmission: false, hostObjectType: null);
workspace.AddProject(projectInfo);
foreach (var doc in documents)
{
workspace.OpenDocument(doc.Info.Id);
}
// Initialize the code after Roslyn has initialized so colorization works. The caret
// will force creation of lines and they won't be colorized if Roslyn hasn't init'd yet.
for (int i = 0; i < documents.Count; i++)
{
var doc = decompiledCodeResult.Documents[i];
var textBuffer = documents[i].TextView.TextBuffer;
textBuffer.Replace(new Span(0, textBuffer.CurrentSnapshot.Length), doc.Code);
}
return(documents.ToArray());
}
public void TestOpenCloseDocument()
{
var pid = ProjectId.CreateNewId();
var text = SourceText.From("public class C { }");
var version = VersionStamp.Create();
var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version)));
var projInfo = ProjectInfo.Create(
pid,
version: VersionStamp.Default,
name: "TestProject",
assemblyName: "TestProject.dll",
language: LanguageNames.CSharp,
documents: new[] { docInfo });
using (var ws = new AdhocWorkspace())
{
ws.AddProject(projInfo);
SourceText currentText;
VersionStamp currentVersion;
var doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.Equal(false, doc.TryGetText(out currentText));
ws.OpenDocument(docInfo.Id);
doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.Equal(true, doc.TryGetText(out currentText));
Assert.Equal(true, doc.TryGetTextVersion(out currentVersion));
Assert.Same(text, currentText);
Assert.Equal(version, currentVersion);
ws.CloseDocument(docInfo.Id);
doc = ws.CurrentSolution.GetDocument(docInfo.Id);
Assert.Equal(false, doc.TryGetText(out currentText));
}
}
async Task InitializeAsync(ITextBuffer buffer, string code, MetadataReference[] refs, string languageName, ISynchronousTagger <IClassificationTag> tagger, CompilationOptions compilationOptions, ParseOptions parseOptions)
{
using (var workspace = new AdhocWorkspace(RoslynMefHostServices.DefaultServices)) {
var documents = new List <DocumentInfo>();
var projectId = ProjectId.CreateNewId();
documents.Add(DocumentInfo.Create(DocumentId.CreateNewId(projectId), "main.cs", null, SourceCodeKind.Regular, TextLoader.From(buffer.AsTextContainer(), VersionStamp.Create())));
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), "compilecodeproj", Guid.NewGuid().ToString(), languageName,
compilationOptions: compilationOptions
.WithOptimizationLevel(OptimizationLevel.Release)
.WithPlatform(Platform.AnyCpu)
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default),
parseOptions: parseOptions,
documents: documents,
metadataReferences: refs,
isSubmission: false, hostObjectType: null);
workspace.AddProject(projectInfo);
foreach (var doc in documents)
{
workspace.OpenDocument(doc.Id);
}
buffer.Replace(new Span(0, buffer.CurrentSnapshot.Length), code);
{
// Initialize classification code paths
var spans = new NormalizedSnapshotSpanCollection(new SnapshotSpan(buffer.CurrentSnapshot, 0, buffer.CurrentSnapshot.Length));
foreach (var tagSpan in tagger.GetTags(spans, CancellationToken.None))
{
}
}
{
// Initialize completion code paths
var info = CompletionInfo.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
var completionTrigger = CompletionTrigger.Invoke;
var completionList = await info.Value.CompletionService.GetCompletionsAsync(info.Value.Document, 0, completionTrigger);
}
}
{
// Initialize signature help code paths
var info = SignatureHelpInfo.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
int sigHelpIndex = code.IndexOf("sighelp");
Debug.Assert(sigHelpIndex >= 0);
var triggerInfo = new SignatureHelpTriggerInfo(SignatureHelpTriggerReason.InvokeSignatureHelpCommand);
var items = await info.Value.SignatureHelpService.GetItemsAsync(info.Value.Document, sigHelpIndex, triggerInfo);
}
}
{
// Initialize quick info code paths
var info = QuickInfoState.Create(buffer.CurrentSnapshot);
Debug.Assert(info != null);
if (info != null)
{
int quickInfoIndex = code.IndexOf("Equals");
Debug.Assert(quickInfoIndex >= 0);
var item = await info.Value.QuickInfoService.GetItemAsync(info.Value.Document, quickInfoIndex);
}
}
}
}
public async Task TestOpenFileOnlyAnalyzerDiagnostics()
{
var workspace = new AdhocWorkspace();
var project = workspace.AddProject(
ProjectInfo.Create(
ProjectId.CreateNewId(),
VersionStamp.Create(),
"CSharpProject",
"CSharpProject",
LanguageNames.CSharp));
var document = workspace.AddDocument(project.Id, "Empty.cs", SourceText.From(""));
// create listener/service/analyzer
var listener = new AsynchronousOperationListener();
var service = new MyDiagnosticAnalyzerService(new OpenFileOnlyAnalyzer(), listener);
var analyzer = service.CreateIncrementalAnalyzer(workspace);
// listen to events
service.DiagnosticsUpdated += (s, a) =>
{
if (workspace.IsDocumentOpen(a.DocumentId))
{
// check the diagnostics are reported
Assert.Equal(document.Id, a.DocumentId);
Assert.Equal(1, a.Diagnostics.Length);
Assert.Equal(OpenFileOnlyAnalyzer.s_syntaxRule.Id, a.Diagnostics[0].Id);
}
if (a.DocumentId == document.Id && !workspace.IsDocumentOpen(a.DocumentId))
{
// check the diagnostics reported are cleared
Assert.Equal(0, a.Diagnostics.Length);
}
};
// open document
workspace.OpenDocument(document.Id);
await analyzer.DocumentOpenAsync(document, CancellationToken.None).ConfigureAwait(false);
// cause analysis
await RunAllAnalysisAsync(analyzer, document).ConfigureAwait(false);
// close document
workspace.CloseDocument(document.Id);
await analyzer.DocumentCloseAsync(document, CancellationToken.None).ConfigureAwait(false);
await RunAllAnalysisAsync(analyzer, document).ConfigureAwait(false);
// wait for all events to raised
await listener.CreateWaitTask().ConfigureAwait(false);
}