protected async Task RunAsync(string[] sources, string[] filePaths, params DiagnosticResult[] expected) { var analyzer = Analyzer; var diagnostics = await DiagnosticRunner.GetSortedDiagnosticsAsync(sources, filePaths, analyzer); DiagnosticVerifier.VerifyDiagnosticResults(diagnostics, analyzer, expected); }
/// <summary> /// General verifier for codefixes. /// Creates a Document from the source string, then gets diagnostics on it and applies the relevant codefixes. /// Then gets the string after the codefix is applied and compares it with the expected result. /// Note: If any codefix causes new diagnostics to show up, the test fails unless allowNewCompilerDiagnostics is set to true. /// </summary> /// <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="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="oldDocumentPath">Optional document path</param> /// <param name="newDocumentPath">Optional new document path</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> public static async Task VerifyFixAsync(DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string oldSource, string newSource, string oldDocumentPath, string newDocumentPath, int?codeFixIndex, bool allowNewCompilerDiagnostics) { var document = oldDocumentPath != null ? DocumentProvider.GetDocument(oldSource, oldDocumentPath) : DocumentProvider.GetDocument(oldSource); var analyzerDiagnostics = await DiagnosticRunner.GetSortedDiagnosticsFromDocumentsAsync(analyzer, new[] { document }); var compilerDiagnostics = await GetCompilerDiagnosticsAsync(document); var attempts = analyzerDiagnostics.Length; 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); if (!actions.Any()) { break; } if (codeFixIndex != null) { document = await ApplyFixAsync(document, actions.ElementAt((int)codeFixIndex)); break; } document = await ApplyFixAsync(document, actions.ElementAt(0)); analyzerDiagnostics = await DiagnosticRunner.GetSortedDiagnosticsFromDocumentsAsync(analyzer, new[] { document }); var newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document)); //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(), Formatter.Annotation, document.Project.Solution.Workspace)); newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, await GetCompilerDiagnosticsAsync(document)); Assert.True(false, string.Format("Fix introduced new compiler diagnostics:\r\n{0}\r\n\r\nNew document:\r\n{1}\r\n", string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString())), (await document.GetSyntaxRootAsync()).ToFullString())); } //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); Assert.Equal(newSource.HomogenizeLineEndings(), actual.HomogenizeLineEndings()); if (!string.IsNullOrWhiteSpace(newDocumentPath)) { Assert.Equal(Path.GetFileName(newDocumentPath), document.Name); } }