public async Task VerifyNoDiagnosticAsync(
string source,
IEnumerable <string> additionalSources = null,
CodeVerificationOptions options = null,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
options ??= Options;
if (SupportedDiagnostics.IndexOf(Descriptor, DiagnosticDescriptorComparer.Id) == -1)
{
Assert.True(false, $"Diagnostic \"{Descriptor.Id}\" is not supported by analyzer \"{Analyzer.GetType().Name}\".");
}
using (Workspace workspace = new AdhocWorkspace())
{
Project project = WorkspaceFactory.AddProject(workspace.CurrentSolution, options);
Document document = WorkspaceFactory.AddDocument(project, source, additionalSources);
Compilation compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
ImmutableArray <Diagnostic> compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
VerifyCompilerDiagnostics(compilerDiagnostics, options);
if (!Descriptor.IsEnabledByDefault)
{
compilation = compilation.EnsureEnabled(Descriptor);
}
ImmutableArray <Diagnostic> analyzerDiagnostics = await compilation.GetAnalyzerDiagnosticsAsync(Analyzer, DiagnosticComparer.SpanStart, cancellationToken).ConfigureAwait(false);
foreach (Diagnostic diagnostic in analyzerDiagnostics)
{
if (string.Equals(diagnostic.Id, Descriptor.Id, StringComparison.Ordinal))
{
Assert.True(false, $"No diagnostic expected{analyzerDiagnostics.Where(f => string.Equals(f.Id, Descriptor.Id, StringComparison.Ordinal)).ToDebugString()}");
}
}
}
}
internal DiagnosticVerifier(WorkspaceFactory workspaceFactory) : base(workspaceFactory)
{
}
internal FixVerifier(WorkspaceFactory workspaceFactory, IAssert assert) : base(workspaceFactory, assert)
{
}
internal CompilerDiagnosticFixVerifier(WorkspaceFactory workspaceFactory) : base(workspaceFactory)
{
}
internal RefactoringVerifier(WorkspaceFactory workspaceFactory) : base(workspaceFactory)
{
}
public async Task VerifyRefactoringAsync(
string source,
string expected,
TextSpan span,
IEnumerable <string> additionalSources = null,
string equivalenceKey = null,
CodeVerificationOptions options = null,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
options ??= Options;
using (Workspace workspace = new AdhocWorkspace())
{
Project project = WorkspaceFactory.AddProject(workspace.CurrentSolution, options);
Document document = WorkspaceFactory.AddDocument(project, source, additionalSources);
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ImmutableArray <Diagnostic> compilerDiagnostics = semanticModel.GetDiagnostics(cancellationToken: cancellationToken);
VerifyCompilerDiagnostics(compilerDiagnostics, options);
CodeAction action = null;
var context = new CodeRefactoringContext(
document,
span,
a =>
{
if (equivalenceKey == null ||
string.Equals(a.EquivalenceKey, equivalenceKey, StringComparison.Ordinal))
{
if (action == null)
{
action = a;
}
}
},
CancellationToken.None);
await RefactoringProvider.ComputeRefactoringsAsync(context).ConfigureAwait(false);
Assert.True(action != null, "No code refactoring has been registered.");
document = await document.ApplyCodeActionAsync(action).ConfigureAwait(false);
semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ImmutableArray <Diagnostic> newCompilerDiagnostics = semanticModel.GetDiagnostics(cancellationToken: cancellationToken);
VerifyCompilerDiagnostics(newCompilerDiagnostics, options);
VerifyNoNewCompilerDiagnostics(compilerDiagnostics, newCompilerDiagnostics, options);
string actual = await document.ToFullStringAsync(simplify : true, format : true, cancellationToken).ConfigureAwait(false);
Assert.Equal(expected, actual);
}
}
internal FixVerifier(WorkspaceFactory workspaceFactory) : base(workspaceFactory)
{
}
internal DiagnosticVerifier(WorkspaceFactory workspaceFactory, IAssert assert) : base(workspaceFactory, assert)
{
}
internal CodeVerifier(WorkspaceFactory workspaceFactory)
{
WorkspaceFactory = workspaceFactory;
}
public async Task VerifyDiagnosticAsync(
string source,
IEnumerable <Diagnostic> expectedDiagnostics,
IEnumerable <string> additionalSources = null,
CodeVerificationOptions options = null,
CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
options ??= Options;
using (Workspace workspace = new AdhocWorkspace())
{
Project project = WorkspaceFactory.AddProject(workspace.CurrentSolution, options);
Document document = WorkspaceFactory.AddDocument(project, source, additionalSources);
Compilation compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
ImmutableArray <Diagnostic> compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
VerifyCompilerDiagnostics(compilerDiagnostics, options);
if (!Descriptor.IsEnabledByDefault)
{
compilation = compilation.EnsureEnabled(Descriptor);
}
ImmutableArray <Diagnostic> diagnostics = await compilation.GetAnalyzerDiagnosticsAsync(Analyzer, DiagnosticComparer.SpanStart, cancellationToken).ConfigureAwait(false);
if (diagnostics.Length > 0 &&
SupportedDiagnostics.Length > 1)
{
VerifyDiagnostics(FilterDiagnostics(diagnostics), expectedDiagnostics, cancellationToken);
}
else
{
VerifyDiagnostics(diagnostics, expectedDiagnostics, cancellationToken);
}
}
IEnumerable <Diagnostic> FilterDiagnostics(ImmutableArray <Diagnostic> diagnostics)
{
foreach (Diagnostic diagnostic in diagnostics)
{
bool success = false;
foreach (Diagnostic expectedDiagnostic in expectedDiagnostics)
{
if (DiagnosticComparer.Id.Equals(diagnostic, expectedDiagnostic))
{
success = true;
break;
}
}
if (success)
{
yield return(diagnostic);
}
}
}
}
internal CompilerDiagnosticFixVerifier(WorkspaceFactory workspaceFactory, IAssert assert) : base(workspaceFactory, assert)
{
}
internal CodeVerifier(WorkspaceFactory workspaceFactory, IAssert assert)
{
WorkspaceFactory = workspaceFactory;
Assert = assert;
TextParser = new DefaultTextParser(Assert);
}
internal RefactoringVerifier(WorkspaceFactory workspaceFactory, IAssert assert) : base(workspaceFactory, assert)
{
}
