/// <summary>
/// Create a project using the inputted strings as sources.
/// </summary>
/// <param name="sources">Classes in the form of strings</param>
/// <param name="language">The language the source code is in</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <returns>A Project created out of the Douments created from the source strings</returns>
public static Project CreateProject(string[] sources,
string language,
LanguageVersion languageVersionCSharp,
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var fileNamePrefix = DefaultFilePathPrefix;
string fileExt;
ParseOptions parseOptions;
if (language == LanguageNames.CSharp)
{
fileExt = CSharpDefaultFileExt;
parseOptions = new CSharpParseOptions(languageVersionCSharp);
}
else
{
fileExt = VisualBasicDefaultExt;
parseOptions = new Microsoft.CodeAnalysis.VisualBasic.VisualBasicParseOptions(languageVersionVB);
}
var projectId = ProjectId.CreateNewId(debugName: TestProjectName);
#pragma warning disable CC0022
var workspace = new AdhocWorkspace();
#pragma warning restore CC0022
var projectInfo = ProjectInfo.Create(projectId, VersionStamp.Create(), TestProjectName,
TestProjectName, language,
parseOptions: parseOptions,
metadataReferences: ImmutableList.Create(
CorlibReference, SystemCoreReference, RegexReference,
CSharpSymbolsReference, CodeAnalysisReference, JsonNetReference));
workspace.AddProject(projectInfo);
var count = 0;
foreach (var source in sources)
{
var newFileName = fileNamePrefix + count + "." + fileExt;
workspace.AddDocument(projectId, newFileName, SourceText.From(source));
count++;
}
var project = workspace.CurrentSolution.GetProject(projectId);
var newCompilationOptions = project.CompilationOptions.WithSpecificDiagnosticOptions(diagOptions);
var newSolution = workspace.CurrentSolution.WithProjectCompilationOptions(projectId, newCompilationOptions);
var newProject = newSolution.GetProject(projectId);
return(newProject);
}
/// <summary>
/// Called to test a VB codefix when applied on the inputted string as a source
/// </summary>
/// <param name="oldSource">A class in the form of a string before the CodeFix was applied to it</param>
/// <param name="newSource">A class in the form of a string after the CodeFix was applied to it</param>
/// <param name="codeFixIndex">Index determining which codefix to apply if there are multiple</param>
/// <param name="allowNewCompilerDiagnostics">A bool controlling whether or not the test will fail if the CodeFix introduces other warnings after being applied</param>
/// <param name="formatBeforeCompare">Format the code before comparing, bot the old source and the new.</param>
/// <param name="codeFixProvider">The codefix to be applied to the code wherever the relevant Diagnostic is found</param>
/// <param name="languageVersionVB">The VB language version.</param>
protected async Task VerifyBasicFixAsync(string oldSource, string newSource, int?codeFixIndex = null, bool allowNewCompilerDiagnostics = false, bool formatBeforeCompare = false, CodeFixProvider codeFixProvider = null, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14)
{
if (formatBeforeCompare)
{
oldSource = await FormatSourceAsync(LanguageNames.VisualBasic, oldSource, languageVersionVB : languageVersionVB).ConfigureAwait(true);
newSource = await FormatSourceAsync(LanguageNames.VisualBasic, newSource, languageVersionVB : languageVersionVB).ConfigureAwait(true);
}
codeFixProvider = codeFixProvider ?? GetCodeFixProvider();
var diagnosticAnalyzer = GetDiagnosticAnalyzer();
if (diagnosticAnalyzer != null)
{
await VerifyFixAsync(LanguageNames.VisualBasic, diagnosticAnalyzer, codeFixProvider, oldSource, newSource, codeFixIndex, allowNewCompilerDiagnostics, LanguageVersion.CSharp6, languageVersionVB).ConfigureAwait(true);
}
else
{
await VerifyFixAsync(LanguageNames.VisualBasic, codeFixProvider.FixableDiagnosticIds, codeFixProvider, oldSource, newSource, codeFixIndex, allowNewCompilerDiagnostics, LanguageVersion.CSharp6, languageVersionVB).ConfigureAwait(true);
}
}
/// <summary>
/// General verifier for a diagnostics that should not have fix registred.
/// Creates a Document from the source string, then gets diagnostics on it and verify if it has no fix registred.
/// It will fail the test if it has any fix registred to it
/// </summary>
/// <param name="language">The language the source code is in</param>
/// <param name="analyzer">The analyzer to be applied to the source code</param>
/// <param name="codeFixProvider">The codefix to be applied to the code wherever the relevant Diagnostic is found</param>
/// <param name="source">A class in the form of a string before the CodeFix was applied to it</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
private async static Task VerifyHasNoFixAsync(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string source, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var document = CreateDocument(source, language, languageVersionCSharp, languageVersionVB);
var analyzerDiagnostics = await GetSortedDiagnosticsFromDocumentsAsync(analyzer, new[] { document }).ConfigureAwait(true);
foreach (var analyzerDiagnostic in analyzerDiagnostics)
{
var actions = new List <CodeAction>();
var context = new CodeFixContext(document, analyzerDiagnostic, (a, d) => actions.Add(a), CancellationToken.None);
await codeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(true);
Assert.False(actions.Any(), $"Should not have a code fix registered for diagnostic '{analyzerDiagnostic.Id}'");
}
}
private async static Task VerifyFixAllAsync(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string[] oldSources, string[] newSources, bool allowNewCompilerDiagnostics, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB, string equivalenceKey = null)
{
var project = CreateProject(oldSources, language, languageVersionCSharp, languageVersionVB);
var compilerDiagnostics = (await Task.WhenAll(project.Documents.Select(d => GetCompilerDiagnosticsAsync(d))).ConfigureAwait(true)).SelectMany(d => d);
var fixAllProvider = codeFixProvider.GetFixAllProvider();
if (equivalenceKey == null)
{
equivalenceKey = codeFixProvider.GetType().Name;
}
FixAllContext fixAllContext;
if (analyzer != null)
{
var analyzerDiagnostics = await GetSortedDiagnosticsFromDocumentsAsync(analyzer, project.Documents.ToArray()).ConfigureAwait(true);
Func <Document, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > > getDocumentDiagnosticsAsync = (doc, ids, ct) =>
Task.FromResult(analyzerDiagnostics.Where(d => d.Location.SourceTree.FilePath == doc.Name));
Func <Project, bool, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > > getProjectDiagnosticsAsync = (proj, b, ids, ct) =>
Task.FromResult((IEnumerable <Diagnostic>)analyzerDiagnostics); //todo: verify, probably wrong
var fixAllDiagnosticProvider = new FixAllDiagnosticProvider(codeFixProvider.FixableDiagnosticIds.ToImmutableHashSet(), getDocumentDiagnosticsAsync, getProjectDiagnosticsAsync);
fixAllContext = new FixAllContext(project.Documents.First(), codeFixProvider, FixAllScope.Solution,
equivalenceKey,
codeFixProvider.FixableDiagnosticIds,
fixAllDiagnosticProvider,
CancellationToken.None);
}
else
{
Func <Document, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > > getDocumentDiagnosticsAsync = async(doc, ids, ct) =>
{
var compilerDiags = await GetCompilerDiagnosticsAsync(doc).ConfigureAwait(true);
return(compilerDiags.Where(d => codeFixProvider.FixableDiagnosticIds.Contains(d.Id)));
};
Func <Project, bool, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > > getProjectDiagnosticsAsync = async(proj, b, ids, ct) =>
{
var theDocs = proj.Documents;
var diags = await Task.WhenAll(theDocs.Select(d => getDocumentDiagnosticsAsync(d, ids, ct))).ConfigureAwait(true);
return(diags.SelectMany(d => d));
};
var fixAllDiagnosticProvider = new FixAllDiagnosticProvider(codeFixProvider.FixableDiagnosticIds.ToImmutableHashSet(), getDocumentDiagnosticsAsync, getProjectDiagnosticsAsync);
fixAllContext = new FixAllContext(project.Documents.First(), codeFixProvider, FixAllScope.Solution,
equivalenceKey,
codeFixProvider.FixableDiagnosticIds,
fixAllDiagnosticProvider,
CancellationToken.None);
}
var action = await fixAllProvider.GetFixAsync(fixAllContext).ConfigureAwait(true);
if (action == null)
{
throw new Exception("No action supplied for the code fix.");
}
project = await ApplyFixAsync(project, action).ConfigureAwait(true);
//check if applying the code fix introduced any new compiler diagnostics
var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, (await Task.WhenAll(project.Documents.Select(d => GetCompilerDiagnosticsAsync(d))).ConfigureAwait(true)).SelectMany(d => d));
if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
{
Assert.True(false, $"Fix introduced new compiler diagnostics:\r\n{string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString()))}\r\n");
}
var docs = project.Documents.ToArray();
for (int i = 0; i < docs.Length; i++)
{
var document = docs[i];
var actual = await GetStringFromDocumentAsync(document).ConfigureAwait(true);
newSources[i].Should().Be(actual);
}
}
private async static Task VerifyFixAllAsync(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string oldSource, string newSource, bool allowNewCompilerDiagnostics, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB, string equivalenceKey = null)
{
var document = CreateDocument(oldSource, language, languageVersionCSharp, languageVersionVB);
var compilerDiagnostics = await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true);
var getDocumentDiagnosticsAsync = analyzer != null
? (Func <Document, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > >)(async(doc, ids, ct) =>
await GetSortedDiagnosticsFromDocumentsAsync(analyzer, new[] { doc }).ConfigureAwait(true))
: (async(doc, ids, ct) =>
{
var compilerDiags = await GetCompilerDiagnosticsAsync(doc).ConfigureAwait(true);
return(compilerDiags.Where(d => codeFixProvider.FixableDiagnosticIds.Contains(d.Id)));
});
Func <Project, bool, ImmutableHashSet <string>, CancellationToken, Task <IEnumerable <Diagnostic> > > getProjectDiagnosticsAsync = async(proj, b, ids, ct) =>
{
var theDocs = proj.Documents;
var diags = await Task.WhenAll(theDocs.Select(d => getDocumentDiagnosticsAsync?.Invoke(d, ids, ct))).ConfigureAwait(true);
return(diags.SelectMany(d => d));
};
var fixAllProvider = codeFixProvider.GetFixAllProvider();
var fixAllDiagnosticProvider = new FixAllDiagnosticProvider(codeFixProvider.FixableDiagnosticIds.ToImmutableHashSet(), getDocumentDiagnosticsAsync, getProjectDiagnosticsAsync);
if (equivalenceKey == null)
{
equivalenceKey = codeFixProvider.GetType().Name;
}
var fixAllContext = new FixAllContext(document, codeFixProvider, FixAllScope.Document,
equivalenceKey,
codeFixProvider.FixableDiagnosticIds,
fixAllDiagnosticProvider,
CancellationToken.None);
var action = await fixAllProvider.GetFixAsync(fixAllContext).ConfigureAwait(true);
if (action == null)
{
throw new Exception("No action supplied for the code fix.");
}
document = await ApplyFixAsync(document, action).ConfigureAwait(true);
//check if applying the code fix introduced any new compiler diagnostics
var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true));
if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
{
// Format and get the compiler diagnostics again so that the locations make sense in the output
document = document.WithSyntaxRoot(Formatter.Format(await document.GetSyntaxRootAsync().ConfigureAwait(true), Formatter.Annotation, document.Project.Solution.Workspace));
newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true));
Assert.True(false, $"Fix introduced new compiler diagnostics:\r\n{string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString()))}\r\n\r\nNew document:\r\n{(await document.GetSyntaxRootAsync().ConfigureAwait(true)).ToFullString()}\r\n");
}
var actual = await GetStringFromDocumentAsync(document).ConfigureAwait(true);
Assert.Equal(newSource, actual);
}
protected async Task VerifyBasicFixAllAsync(string oldSource, string newSource, bool allowNewCompilerDiagnostics = false, bool formatBeforeCompare = true, CodeFixProvider codeFixProvider = null, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14, string equivalenceKey = null)
{
if (formatBeforeCompare)
{
oldSource = await FormatSourceAsync(LanguageNames.VisualBasic, oldSource, languageVersionVB : languageVersionVB).ConfigureAwait(true);
newSource = await FormatSourceAsync(LanguageNames.VisualBasic, newSource, languageVersionVB : languageVersionVB).ConfigureAwait(true);
}
codeFixProvider = codeFixProvider ?? GetCodeFixProvider();
await VerifyFixAllAsync(LanguageNames.VisualBasic, GetDiagnosticAnalyzer(), codeFixProvider, oldSource, newSource, allowNewCompilerDiagnostics, LanguageVersion.CSharp6, languageVersionVB, equivalenceKey).ConfigureAwait(true);
}
private async static Task VerifyFixAsync(string language, ImmutableArray <string> diagnosticIds, CodeFixProvider codeFixProvider, string oldSource, string newSource, int?codeFixIndex, bool allowNewCompilerDiagnostics, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var document = CreateDocument(oldSource, language, languageVersionCSharp, languageVersionVB);
var compilerDiagnostics = (await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true)).ToList();
var analyzerDiagnostics = compilerDiagnostics.Where(c => diagnosticIds.Contains(c.Id)).ToList();
var attempts = analyzerDiagnostics.Count;
for (int i = 0; i < attempts; ++i)
{
var actions = new List <CodeAction>();
var context = new CodeFixContext(document, analyzerDiagnostics[0], (a, d) => actions.Add(a), CancellationToken.None);
await codeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(true);
if (!actions.Any())
{
break;
}
document = codeFixIndex != null
? await ApplyFixAsync(document, actions.ElementAt((int)codeFixIndex)).ConfigureAwait(true)
: await ApplyFixAsync(document, actions.ElementAt(0)).ConfigureAwait(true);
var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true));
compilerDiagnostics = (await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true)).ToList();
analyzerDiagnostics = compilerDiagnostics.Where(c => diagnosticIds.Contains(c.Id)).ToList();
//check if applying the code fix introduced any new compiler diagnostics
if (!allowNewCompilerDiagnostics && newCompilerDiagnostics.Any())
{
// Format and get the compiler diagnostics again so that the locations make sense in the output
document = document.WithSyntaxRoot(Formatter.Format(await document.GetSyntaxRootAsync().ConfigureAwait(true), Formatter.Annotation, document.Project.Solution.Workspace));
newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document).ConfigureAwait(true));
Assert.True(false, $"Fix introduced new compiler diagnostics:\r\n{string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString()))}\r\n\r\nNew document:\r\n{(await document.GetSyntaxRootAsync().ConfigureAwait(true)).ToFullString()}\r\n");
}
//check if there are analyzer diagnostics left after the code fix
if (!analyzerDiagnostics.Any())
{
break;
}
}
//after applying all of the code fixes, compare the resulting string to the inputted one
var actual = await GetStringFromDocumentAsync(document).ConfigureAwait(true);
Assert.Equal(newSource, actual);
}
/// <summary> /// Given classes in the form of strings, their language, and an IDiagnosticAnlayzer to apply to it, return the diagnostics found in the string after converting it to a document. /// </summary> /// <param name="sources">Classes in the form of strings</param> /// <param name="language">The language the soruce classes are in</param> /// <param name="analyzer">The analyzer to be run on the sources</param> /// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param> /// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param> /// <returns>An IEnumerable of Diagnostics that surfaced in teh source code, sorted by Location</returns> private static async Task <Diagnostic[]> GetSortedDiagnosticsAsync(string[] sources, string language, DiagnosticAnalyzer analyzer, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB) => await GetSortedDiagnosticsFromDocumentsAsync(analyzer, GetDocuments(sources, language, languageVersionCSharp, languageVersionVB)).ConfigureAwait(true);
public static async Task <string> FormatSourceAsync(string language, string source, LanguageVersion languageVersionCSharp = LanguageVersion.CSharp6, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14)
{
var document = CreateDocument(source, language, languageVersionCSharp, languageVersionVB);
var newDoc = await Formatter.FormatAsync(document).ConfigureAwait(true);
return((await newDoc.GetSyntaxRootAsync().ConfigureAwait(true)).ToFullString());
}
/// <summary>
/// Given an array of strings as sources and a language, turn them into a project and return the documents and spans of it.
/// </summary>
/// <param name="sources">Classes in the form of strings</param>
/// <param name="language">The language the source code is in</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <returns>A Tuple containing the Documents produced from the sources and thier TextSpans if relevant</returns>
public static Document[] GetDocuments(string[] sources, string language, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
if (language != LanguageNames.CSharp && language != LanguageNames.VisualBasic)
{
throw new ArgumentException("Unsupported Language");
}
for (int i = 0; i < sources.Length; i++)
{
var fileName = language == LanguageNames.CSharp ? nameof(Test) + i + ".cs" : nameof(Test) + i + ".vb";
}
var project = CreateProject(sources, language, languageVersionCSharp, languageVersionVB);
var documents = project.Documents.ToArray();
if (sources.Length != documents.Length)
{
throw new SystemException("Amount of sources did not match amount of Documents created");
}
return(documents);
}
/// <summary>
/// Create a Document from a string through creating a project that contains it.
/// </summary>
/// <param name="source">Classes in the form of a string</param>
/// <param name="language">The language the source code is in</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <returns>A Document created from the source string</returns>
public static Document CreateDocument(string source,
string language,
LanguageVersion languageVersionCSharp,
Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB) =>
CreateProject(new[] { source }, language, languageVersionCSharp, languageVersionVB).Documents.First();
/// <summary>
/// General verifier for a diagnostics that verifies how many code actions a code fix registered.
/// Creates a Document from the source string, then gets diagnostics on it and verify if it has x number of code actions registred.
/// It will fail the test if it has a different number of code actions registred to it.
/// </summary>
/// <param name="language">The language the source code is in</param>
/// <param name="analyzer">The analyzer to be applied to the source code</param>
/// <param name="codeFixProvider">The codefix to be applied to the code wherever the relevant Diagnostic is found</param>
/// <param name="source">A class in the form of a string before the CodeFix was applied to it</param>
/// <param name="languageVersionCSharp">C# language version used for compiling the test project, required unless you inform the VB language version.</param>
/// <param name="languageVersionVB">VB language version used for compiling the test project, required unless you inform the C# language version.</param>
/// <param name="numberOfCodeActions">The expected number of code actions provided by the code fix.</param>
private async static Task VerifyNumberOfCodeActions(string language, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string source, int numberOfCodeActions, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var document = CreateDocument(source, language, languageVersionCSharp, languageVersionVB);
var analyzerDiagnostics = await GetSortedDiagnosticsFromDocumentsAsync(analyzer, new[] { document }).ConfigureAwait(true);
foreach (var analyzerDiagnostic in analyzerDiagnostics)
{
var actions = new List <CodeAction>();
var context = new CodeFixContext(document, analyzerDiagnostic, (a, d) => actions.Add(a), CancellationToken.None);
await codeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(true);
var numberOfCodeActionsFound = actions.Count();
Assert.True(numberOfCodeActions == numberOfCodeActionsFound, $"Should have {numberOfCodeActions} code actions registered for diagnostic '{analyzerDiagnostic.Id}' but got {numberOfCodeActionsFound}.");
}
}
/// <summary> /// Called to test a VB DiagnosticAnalyzer when applied on the inputted strings as a source /// Note: input a DiagnosticResult for each Diagnostic expected /// </summary> /// <param name="sources">An array of strings to create source documents from to run the analyzers on</param> /// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param> /// <param name="languageVersion">The VB language version, defaults to the latest stable version.</param> protected async Task VerifyBasicDiagnosticAsync(string[] sources, DiagnosticResult[] expected, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersion = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14) => await VerifyDiagnosticsAsync(sources, LanguageNames.VisualBasic, GetDiagnosticAnalyzer(), expected, LanguageVersion.CSharp6, languageVersion).ConfigureAwait(true);
protected async Task VerifyBasicDiagnosticAsync(string source, DiagnosticResult expected1, DiagnosticResult expected2, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14) =>
await VerifyDiagnosticsAsync(new[] { source }, LanguageNames.VisualBasic, GetDiagnosticAnalyzer(), new[] { expected1, expected2 }, LanguageVersion.CSharp6, languageVersionVB).ConfigureAwait(true);
protected async Task VerifyBasicHasNoDiagnosticsAsync(string[] sources, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB = Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.VisualBasic14) =>
await VerifyBasicDiagnosticAsync(sources, new DiagnosticResult[] { }, languageVersionVB).ConfigureAwait(true);
/// <summary>
/// General method that gets a collection of actual diagnostics found in the source after the analyzer is run,
/// then verifies each of them.
/// </summary>
/// <param name="sources">An array of strings to create source documents from to run teh analyzers on</param>
/// <param name="language">The language of the classes represented by the source strings</param>
/// <param name="analyzer">The analyzer to be run on the source code</param>
/// <param name="expected">DiagnosticResults that should appear after the analyzer is run on the sources</param>
/// <param name="languageVersionCSharp">The C# language version, default to latest.</param>
/// <param name="languageVersionVB">The VB language version, default to latest.</param>
private async static Task VerifyDiagnosticsAsync(string[] sources, string language, DiagnosticAnalyzer analyzer, DiagnosticResult[] expected, LanguageVersion languageVersionCSharp, Microsoft.CodeAnalysis.VisualBasic.LanguageVersion languageVersionVB)
{
var diagnostics = await GetSortedDiagnosticsAsync(sources, language, analyzer, languageVersionCSharp, languageVersionVB).ConfigureAwait(true);
var defaultFilePath = language == LanguageNames.CSharp ? CSharpDefaultFilePath : VisualBasicDefaultFilePath;
VerifyDiagnosticResults(diagnostics, analyzer, defaultFilePath, expected);
}
