/// <summary>
/// Called to test a C# source generator when applied on the input source as a string.
/// </summary>
/// <param name="testState">The effective input test state.</param>
/// <param name="fixedState">The effective test state after the source generators are applied.</param>
/// <param name="verifier">The verifier to use for test assertions.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected async Task <ImmutableArray <Diagnostic> > VerifySourceGeneratorAsync(SolutionState testState, SolutionState fixedState, IVerifier verifier, CancellationToken cancellationToken)
{
return(await VerifySourceGeneratorAsync(Language, GetSourceGenerators().ToImmutableArray(), testState, fixedState, ApplySourceGeneratorAsync, verifier.PushContext("Source generator application"), cancellationToken));
}
/// <summary>
/// Called to test a C# code fix when applied on the input source as a string.
/// </summary>
/// <param name="testState">The effective input test state.</param>
/// <param name="fixedState">The effective test state after incremental code fixes are applied.</param>
/// <param name="batchFixedState">The effective test state after batch code fixes are applied.</param>
/// <param name="verifier">The verifier to use for test assertions.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> that the task will observe.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
protected async Task VerifyFixAsync(SolutionState testState, SolutionState fixedState, SolutionState batchFixedState, IVerifier verifier, CancellationToken cancellationToken)
{
int numberOfIncrementalIterations;
int numberOfFixAllIterations;
int numberOfFixAllInDocumentIterations;
if (NumberOfIncrementalIterations != null)
{
numberOfIncrementalIterations = NumberOfIncrementalIterations.Value;
}
else
{
if (!HasAnyChange(testState, fixedState))
{
numberOfIncrementalIterations = 0;
}
else
{
// Expect at most one iteration per fixable diagnostic
var fixers = GetCodeFixProviders().ToArray();
var fixableExpectedDiagnostics = testState.ExpectedDiagnostics.Count(diagnostic => fixers.Any(fixer => fixer.FixableDiagnosticIds.Contains(diagnostic.Id)));
numberOfIncrementalIterations = -fixableExpectedDiagnostics;
}
}
if (NumberOfFixAllIterations != null)
{
numberOfFixAllIterations = NumberOfFixAllIterations.Value;
}
else
{
if (!HasAnyChange(testState, batchFixedState))
{
numberOfFixAllIterations = 0;
}
else
{
numberOfFixAllIterations = 1;
}
}
if (NumberOfFixAllInDocumentIterations != null)
{
numberOfFixAllInDocumentIterations = NumberOfFixAllInDocumentIterations.Value;
}
else
{
numberOfFixAllInDocumentIterations = numberOfFixAllIterations;
}
var t1 = VerifyFixAsync(Language, GetDiagnosticAnalyzers().ToImmutableArray(), GetCodeFixProviders().ToImmutableArray(), testState, fixedState, numberOfIncrementalIterations, FixEachAnalyzerDiagnosticAsync, verifier.PushContext("Iterative code fix application"), cancellationToken).ConfigureAwait(false);
var fixAllProvider = GetCodeFixProviders().Select(codeFixProvider => codeFixProvider.GetFixAllProvider()).Where(codeFixProvider => codeFixProvider != null).ToImmutableArray();
if (fixAllProvider.IsEmpty)
{
await t1;
}
else
{
if (Debugger.IsAttached)
{
await t1;
}
var t2 = VerifyFixAsync(Language, GetDiagnosticAnalyzers().ToImmutableArray(), GetCodeFixProviders().ToImmutableArray(), testState, batchFixedState, numberOfFixAllInDocumentIterations, FixAllAnalyzerDiagnosticsInDocumentAsync, verifier.PushContext("Fix all in document"), cancellationToken).ConfigureAwait(false);
if (Debugger.IsAttached)
{
await t2;
}
var t3 = VerifyFixAsync(Language, GetDiagnosticAnalyzers().ToImmutableArray(), GetCodeFixProviders().ToImmutableArray(), testState, batchFixedState, numberOfFixAllIterations, FixAllAnalyzerDiagnosticsInProjectAsync, verifier.PushContext("Fix all in project"), cancellationToken).ConfigureAwait(false);
if (Debugger.IsAttached)
{
await t3;
}
var t4 = VerifyFixAsync(Language, GetDiagnosticAnalyzers().ToImmutableArray(), GetCodeFixProviders().ToImmutableArray(), testState, batchFixedState, numberOfFixAllIterations, FixAllAnalyzerDiagnosticsInSolutionAsync, verifier.PushContext("Fix all in solution"), cancellationToken).ConfigureAwait(false);
if (Debugger.IsAttached)
{
await t4;
}
if (!Debugger.IsAttached)
{
// Allow the operations to run in parallel
await t1;
await t2;
await t3;
await t4;
}
}
}
