public void BinarySolution() { var binaryReferencedCode = @" namespace BinaryReferencedAssembly { public class Base { private int _fieldName; } }"; var code = @" namespace RoslynSandbox { using System.Reflection; public class C : BinaryReferencedAssembly.Base { private int f; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var solution = CodeFactory.CreateSolution( code, CodeFactory.DefaultCompilationOptions(new[] { analyzer }), AnalyzerAssert.MetadataReferences.Append(Asserts.MetadataReferences.CreateBinary(binaryReferencedCode))); AnalyzerAssert.Valid(analyzer, solution); }
public static void SingleDocumentTwoErrors() { var code = @" namespace N { class C { private readonly int _value1; private readonly int _value2; } }"; var after = @" namespace N { class C { private readonly int value1; private readonly int value2; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var compilationOptions = CodeFactory.DefaultCompilationOptions(analyzer); var metadataReferences = new[] { MetadataReference.CreateFromFile(typeof(int).Assembly.Location) }; var sln = CodeFactory.CreateSolution(code, compilationOptions, metadataReferences); var diagnostics = Analyze.GetDiagnostics(sln, analyzer); var fixedSln = Fix.Apply(sln, new DoNotUseUnderscoreFix(), diagnostics); CodeAssert.AreEqual(after, fixedSln.Projects.Single().Documents.Single()); }
public void SingleClassOneErrorCorrectFixAll() { var code = @" namespace RoslynSandbox { class Foo { private readonly int _value; } }"; var fixedCode = @" namespace RoslynSandbox { class Foo { private readonly int value; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var cSharpCompilationOptions = CodeFactory.DefaultCompilationOptions(analyzer); var metadataReferences = new[] { MetadataReference.CreateFromFile(typeof(int).Assembly.Location) }; var sln = CodeFactory.CreateSolution(code, cSharpCompilationOptions, metadataReferences); var diagnostics = Analyze.GetDiagnostics(sln, analyzer); var fixedSln = Fix.Apply(sln, new DontUseUnderscoreCodeFixProvider(), diagnostics); CodeAssert.AreEqual(fixedCode, fixedSln.Projects.Single().Documents.Single()); }
public static async Task SingleDocumentOneError() { var code = @" namespace N { class C { private readonly int _value; } }"; var after = @" namespace N { class C { private readonly int value; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var cSharpCompilationOptions = CodeFactory.DefaultCompilationOptions(analyzer); var metadataReferences = new[] { MetadataReference.CreateFromFile(typeof(int).Assembly.Location) }; var sln = CodeFactory.CreateSolution(code, cSharpCompilationOptions, metadataReferences); var diagnostic = Analyze.GetDiagnostics(sln, analyzer).SelectMany(x => x).Single(); var fixedSln = Fix.Apply(sln, new DoNotUseUnderscoreFix(), diagnostic); CodeAssert.AreEqual(after, fixedSln.Projects.Single().Documents.Single()); fixedSln = await Fix.ApplyAsync(sln, new DoNotUseUnderscoreFix(), diagnostic).ConfigureAwait(false); CodeAssert.AreEqual(after, fixedSln.Projects.Single().Documents.Single()); }
public static async Task Project() { var analyzer = new FieldNameMustNotBeginWithUnderscore(); var sln = CodeFactory.CreateSolution(ProjectFile.Find("Gu.Roslyn.Asserts.csproj")); var benchmark = await Benchmark.CreateAsync(sln.Projects.Single(), analyzer).ConfigureAwait(false); CollectionAssert.IsNotEmpty(benchmark.SyntaxNodeActions); Assert.AreSame(analyzer, benchmark.Analyzer); benchmark.Run(); benchmark.Run(); }
public async Task Project() { var analyzer = new FieldNameMustNotBeginWithUnderscore(); var sln = CodeFactory.CreateSolution( CodeFactory.FindProjectFile("Gu.Roslyn.Asserts.csproj"), MetadataReferences.Transitive(typeof(Benchmark).Assembly).ToArray()); var benchmark = await Benchmark.CreateAsync(sln.Projects.Single(), analyzer).ConfigureAwait(false); CollectionAssert.IsNotEmpty(benchmark.SyntaxNodeActions); Assert.AreSame(analyzer, benchmark.Analyzer); benchmark.Run(); benchmark.Run(); }
public static async Task Solution() { var analyzer = new FieldNameMustNotBeginWithUnderscore(); var sln = CodeFactory.CreateSolution(SolutionFile.Find("Gu.Roslyn.Asserts.sln")); var benchmark = await Benchmark.CreateAsync(sln, analyzer).ConfigureAwait(false); CollectionAssert.IsNotEmpty(benchmark.SyntaxNodeActions); CollectionAssert.AllItemsAreInstancesOfType(benchmark.SyntaxNodeActions.Select(x => x.Context.Node), typeof(FieldDeclarationSyntax)); CollectionAssert.AllItemsAreInstancesOfType(benchmark.SyntaxNodeActions.Select(x => x.Context.ContainingSymbol), typeof(IFieldSymbol)); Assert.AreSame(analyzer, benchmark.Analyzer); benchmark.Run(); benchmark.Run(); }
public async Task ClassLibrary1FieldNameMustNotBeginWithUnderscore() { var analyzer = new FieldNameMustNotBeginWithUnderscore(); var benchmark = await Benchmark.CreateAsync(SolutionWithClassLibrary1, analyzer).ConfigureAwait(false); var expected = new[] { "private int _value;" }; CollectionAssert.AreEqual(expected, benchmark.SyntaxNodeActions.Select(x => x.Context.Node.ToString())); expected = new[] { "ClassLibrary1.ClassLibrary1Class1._value" }; CollectionAssert.AreEqual(expected, benchmark.SyntaxNodeActions.Select(x => x.Context.ContainingSymbol.ToString())); Assert.AreSame(analyzer, benchmark.Analyzer); benchmark.Run(); benchmark.Run(); }
public void OneErrorWithExpectedDiagnosticsWithMessageAndErrorIndicatedInCode() { var code = @" namespace RoslynSandbox { class Foo { private readonly int ↓_value1; } }"; var expectedDiagnostic = ExpectedDiagnostic.CreateFromCodeWithErrorsIndicated("SA1309", "Field '_value1' must not begin with an underscore", code, out code); var analyzer = new FieldNameMustNotBeginWithUnderscore(); AnalyzerAssert.Diagnostics <FieldNameMustNotBeginWithUnderscore>(new[] { expectedDiagnostic }, code); AnalyzerAssert.Diagnostics(analyzer.GetType(), new[] { expectedDiagnostic }, code); AnalyzerAssert.Diagnostics(analyzer, new[] { expectedDiagnostic }, code); }
public static async Task GetDiagnosticsAsyncSolution() { var solutionFile = SolutionFile.Find("Gu.Roslyn.Asserts.sln"); var expected = new[] { "ClassLibrary1Class1.cs(6,21): warning SA1309: Field '_value' must not begin with an underscore", "ClassLibrary2Class1.cs(6,21): warning SA1309: Field '_value' must not begin with an underscore", }; var sln = CodeFactory.CreateSolution(solutionFile, MetadataReferences); var analyzer = new FieldNameMustNotBeginWithUnderscore(); var diagnostics = await Analyze.GetDiagnosticsAsync(sln, analyzer).ConfigureAwait(false); CollectionAssert.AreEquivalent(expected, diagnostics.SelectMany(x => x).Select(SkipDirectory)); diagnostics = Analyze.GetDiagnostics(analyzer, sln); CollectionAssert.AreEquivalent(expected, diagnostics.SelectMany(x => x).Select(SkipDirectory)); }
public void WithExpectedDiagnostic() { var code = @" namespace RoslynSandbox { class Foo { private readonly int value1; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var descriptor = FieldNameMustNotBeginWithUnderscore.Descriptor; AnalyzerAssert.Valid <FieldNameMustNotBeginWithUnderscore>(descriptor, code); AnalyzerAssert.Valid(typeof(FieldNameMustNotBeginWithUnderscore), descriptor, code); AnalyzerAssert.Valid(analyzer, descriptor, code); AnalyzerAssert.Valid <FieldNameMustNotBeginWithUnderscore>(new[] { descriptor }, code); AnalyzerAssert.Valid(typeof(FieldNameMustNotBeginWithUnderscore), new[] { descriptor }, code); AnalyzerAssert.Valid(analyzer, new[] { descriptor }, code); AnalyzerAssert.Valid(analyzer, descriptor, new List <string> { code }); }
public void OneErrorIndicatedPosition() { var code = @" namespace RoslynSandbox { class Foo { private readonly int ↓_value; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var expectedDiagnostic = ExpectedDiagnostic.Create(FieldNameMustNotBeginWithUnderscore.DiagnosticId); AnalyzerAssert.Diagnostics <FieldNameMustNotBeginWithUnderscore>(code); AnalyzerAssert.Diagnostics(typeof(FieldNameMustNotBeginWithUnderscore), code); AnalyzerAssert.Diagnostics(analyzer, code); AnalyzerAssert.Diagnostics(analyzer, code, CodeFactory.DefaultCompilationOptions(analyzer, expectedDiagnostic, AnalyzerAssert.SuppressedDiagnostics), AnalyzerAssert.MetadataReferences); AnalyzerAssert.Diagnostics(analyzer, new[] { code }, CodeFactory.DefaultCompilationOptions(analyzer, expectedDiagnostic, AnalyzerAssert.SuppressedDiagnostics), AnalyzerAssert.MetadataReferences); AnalyzerAssert.Diagnostics <FieldNameMustNotBeginWithUnderscore>(expectedDiagnostic, code); AnalyzerAssert.Diagnostics(typeof(FieldNameMustNotBeginWithUnderscore), expectedDiagnostic, code); AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, code); }
public void SingleClassOneErrorNoFix() { var code = @" namespace RoslynSandbox { class Foo { private readonly int ↓_value; } }"; var analyzer = new FieldNameMustNotBeginWithUnderscore(); var expectedDiagnostic = ExpectedDiagnostic.Create(FieldNameMustNotBeginWithUnderscore.DiagnosticId); AnalyzerAssert.NoFix <FieldNameMustNotBeginWithUnderscore, NoCodeFixProvider>(code); AnalyzerAssert.NoFix <FieldNameMustNotBeginWithUnderscore, NoCodeFixProvider>(expectedDiagnostic, code); AnalyzerAssert.NoFix <FieldNameMustNotBeginWithUnderscore, NoCodeFixProvider>((IReadOnlyList <string>) new[] { code }); AnalyzerAssert.NoFix(analyzer, new NoCodeFixProvider(), code); AnalyzerAssert.NoFix(analyzer, new NoCodeFixProvider(), expectedDiagnostic, code); AnalyzerAssert.NoFix(analyzer, new NoCodeFixProvider(), expectedDiagnostic, new List <string> { code }); AnalyzerAssert.NoFix(analyzer, new NoCodeFixProvider(), new[] { code }, CodeFactory.DefaultCompilationOptions(analyzer, expectedDiagnostic, AnalyzerAssert.SuppressedDiagnostics), AnalyzerAssert.MetadataReferences); }
public void ProjectFromDisk() { var fixedCode = @"// ReSharper disable InconsistentNaming // ReSharper disable ArrangeThisQualifier // ReSharper disable NotAccessedField.Local #pragma warning disable IDE0009 // Member access should be qualified. #pragma warning disable IDE0044 // Add readonly modifier namespace ClassLibrary1 { public class ClassLibrary1Class1 { private int value; public ClassLibrary1Class1(int value) { this.value = value; } } } "; var csproj = ProjectFile.Find("ClassLibrary1.csproj"); var analyzer = new FieldNameMustNotBeginWithUnderscore(); var expectedDiagnostic = ExpectedDiagnostic.Create( FieldNameMustNotBeginWithUnderscore.DiagnosticId, "Field '_value' must not begin with an underscore", Path.Combine(csproj.DirectoryName, "ClassLibrary1Class1.cs"), 9, 20); var sln = CodeFactory.CreateSolution( csproj, analyzer, expectedDiagnostic, metadataReferences: new[] { MetadataReference.CreateFromFile(typeof(int).Assembly.Location) }); AnalyzerAssert.CodeFix(analyzer, new DontUseUnderscoreCodeFixProvider(), expectedDiagnostic, sln, fixedCode); }