public ProjectBuildHandler(ILogger logger, string projectPath, List <string> oldReferences, List <string> references, AnalyzerConfiguration analyzerConfiguration = null) { Logger = logger; _analyzerConfiguration = analyzerConfiguration; _projectPath = projectPath; this.Compilation = CreateManualCompilation(projectPath, references); //We don't want a compilation if there are no older references, because it'll slow down the analysis this.PrePortCompilation = oldReferences?.Any() == true?CreateManualCompilation(projectPath, oldReferences) : null; Errors = new List <string>(); MissingMetaReferences = new List <string>(); var errors = Compilation.GetDiagnostics() .Where(diagnostic => diagnostic.Severity == DiagnosticSeverity.Error && diagnostic.GetMessage()?.Equals(KnownErrors.NoMainMethodMessage) != true); if (errors.Any()) { Logger.LogError($"Build Errors: {Compilation.AssemblyName}: {errors.Count()} " + $"compilation errors: \n\t{string.Join("\n\t", errors.Where(e => false).Select(e => e.ToString()))}"); Logger.LogDebug(String.Join("\n", errors)); foreach (var error in errors) { Errors.Add(error.ToString()); } } else { Logger.LogInformation($"{Compilation.AssemblyName} compiled with no errors"); } }
/// <summary> /// Initializes a new instance of SolutionRewriter, analyzing the solution path using the provided config. /// WARNING: This constructor will rebuild and reanalyze the solution, which will have a performance impact. If you /// have an already analyzed solution, use another constructor /// </summary> /// <param name="analyzerConfiguration">Configuration for code analyzer to be used (AnalyzerConfiguration)</param> /// <param name="solutionFilePath">Path to solution file</param> /// <param name="solutionConfiguration">Configuration for each project in solution to be built</param> public SolutionRewriter(string solutionFilePath, List <ProjectConfiguration> solutionConfiguration, IProjectRewriterFactory projectRewriterFactory = null) { DownloadResourceFiles(); _solutionResult = new SolutionResult(); _projectRewriterFactory = projectRewriterFactory ?? new DefaultProjectRewriterFactory(); AnalyzerConfiguration analyzerConfiguration = new AnalyzerConfiguration(LanguageOptions.CSharp) { MetaDataSettings = new MetaDataSettings() { Annotations = true, DeclarationNodes = true, MethodInvocations = true, ReferenceData = true, LoadBuildData = true, InterfaceDeclarations = true, MemberAccess = true, ElementAccess = true } }; _projectRewriters = new List <ProjectRewriter>(); CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(analyzerConfiguration, LogHelper.Logger); var analyzerResults = analyzer.AnalyzeSolution(solutionFilePath).Result; InitializeProjectRewriters(analyzerResults, solutionConfiguration); }
public WorkspaceBuilder(ILogger logger, string workspacePath, AnalyzerConfiguration analyzerConfiguration = null) { this.ProjectResults = new List <ProjectBuildResult>(); this._workspacePath = workspacePath; this.Logger = logger; _analyzerConfiguration = analyzerConfiguration; }
private CodeAnalyzer CreateDefaultCodeAnalyzer() { // Create a basic logger var loggerFactory = LoggerFactory.Create(builder => builder.SetMinimumLevel(LogLevel.Debug).AddConsole()); var logger = loggerFactory.CreateLogger(""); // Set up analyzer config var configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = false }, MetaDataSettings = { ReferenceData = true, LoadBuildData = true, GenerateBinFiles = true, LocationData = false, MethodInvocations = false, LiteralExpressions = false, LambdaMethods = false, DeclarationNodes = false, Annotations = false, InterfaceDeclarations = false, EnumDeclarations = false, StructDeclarations = false, ReturnStatements = false, InvocationArguments = false, ElementAccess = false, MemberAccess = false } }; return(CodeAnalyzerFactory.GetAnalyzer(configuration, logger)); }
public ProjectBuildHandler(ILogger logger, AnalyzerConfiguration analyzerConfiguration = null) { Logger = logger; _analyzerConfiguration = analyzerConfiguration; Errors = new List <string>(); }
public async Task TestAnalyzer() { string projectPath = string.Concat(GetTstPath(Path.Combine(new[] { "Projects", "CodelyzerDummy", "CodelyzerDummy" })), ".csproj"); AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = true, GenerateGremlinOutput = false, GenerateRDFOutput = false, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = true, ReferenceData = true, LoadBuildData = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); using AnalyzerResult result = await analyzer.AnalyzeProject(projectPath); Assert.True(result != null); }
/// <summary> /// Initializes a new instance of Solution Port, analyzing the solution path using the provided config. /// WARNING: This constructor will rebuild and reanalyze the solution, which will have a performance impact. If you /// have an already analyzed solution, use another constructor /// </summary> /// <param name="solutionFilePath">Path to solution file</param> /// <param name="solutionConfiguration">Configuration for each project in solution to be built</param> public SolutionPort(string solutionFilePath, List<PortCoreConfiguration> solutionConfiguration, ILogger logger = null) { if (logger != null) { LogHelper.Logger = logger; } _portSolutionResult = new PortSolutionResult(solutionFilePath); _solutionPath = solutionFilePath; AnalyzerConfiguration analyzerConfiguration = new AnalyzerConfiguration(LanguageOptions.CSharp); analyzerConfiguration.MetaDataSettings = new MetaDataSettings() { Annotations = true, DeclarationNodes = true, MethodInvocations = true, ReferenceData = true, LoadBuildData = true, InterfaceDeclarations = true }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(analyzerConfiguration, LogHelper.Logger); var analyzerResults = analyzer.AnalyzeSolution(solutionFilePath).Result; _context = new MetricsContext(solutionFilePath, analyzerResults); InitSolutionRewriter(analyzerResults, solutionConfiguration); }
protected List <AnalyzerResult> GenerateSolutionAnalysis(string solutionPath) { AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = false, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = false, ReferenceData = true, LoadBuildData = true, ElementAccess = true, MemberAccess = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); var result = analyzer.AnalyzeSolution(solutionPath).Result; return(result); }
private CodeAnalyzer GetCodeAnalyzer() { AnalyzerConfiguration analyzerConfiguration = new AnalyzerConfiguration(LanguageOptions.CSharp); ExportSettings exportSettings = new ExportSettings() { GenerateGremlinOutput = false, GenerateJsonOutput = false, GenerateRDFOutput = false }; MetaDataSettings metaDataSettings = new MetaDataSettings() { Annotations = false, DeclarationNodes = false, LambdaMethods = false, LiteralExpressions = false, LocationData = false, MethodInvocations = false, ReferenceData = false }; analyzerConfiguration.ExportSettings = exportSettings; analyzerConfiguration.MetaDataSettings = metaDataSettings; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(analyzerConfiguration, LogHelper.Logger); return(analyzer); }
public WorkspaceBuilderHelper(ILogger logger, string workspacePath, AnalyzerConfiguration analyzerConfiguration = null) { this.Logger = logger; this.WorkspacePath = workspacePath; this.Projects = new List <ProjectAnalysisResult>(); this.FailedProjects = new List <ProjectAnalysisResult>(); _analyzerConfiguration = analyzerConfiguration; }
public async Task TestMvcMusicStore() { string solutionPath = Directory.EnumerateFiles(tempDir, "MvcMusicStore.sln", SearchOption.AllDirectories).FirstOrDefault(); FileAssert.Exists(solutionPath); AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = false, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = false, ReferenceData = true, LoadBuildData = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); using var result = (await analyzer.AnalyzeSolution(solutionPath)).FirstOrDefault(); Assert.True(result != null); Assert.False(result.ProjectBuildResult.IsSyntaxAnalysis); Assert.AreEqual(28, result.ProjectResult.SourceFiles.Count); //Project has 16 nuget references and 19 framework/dll references: Assert.AreEqual(29, result.ProjectResult.ExternalReferences.NugetReferences.Count); Assert.AreEqual(24, result.ProjectResult.ExternalReferences.SdkReferences.Count); var homeController = result.ProjectResult.SourceFileResults.Where(f => f.FilePath.EndsWith("HomeController.cs")).FirstOrDefault(); Assert.NotNull(homeController); var classDeclarations = homeController.Children.OfType <Codelyzer.Analysis.Model.NamespaceDeclaration>().FirstOrDefault(); Assert.Greater(classDeclarations.Children.Count, 0); var classDeclaration = homeController.Children.OfType <Codelyzer.Analysis.Model.NamespaceDeclaration>().FirstOrDefault().Children[0]; Assert.NotNull(classDeclaration); var declarationNodes = classDeclaration.Children.OfType <Codelyzer.Analysis.Model.DeclarationNode>(); var methodDeclarations = classDeclaration.Children.OfType <Model.MethodDeclaration>(); //HouseController has 3 identifiers declared within the class declaration: Assert.AreEqual(4, declarationNodes.Count()); //It has 2 method declarations Assert.AreEqual(2, methodDeclarations.Count()); }
public ProjectBuildHandler(ILogger logger, AnalyzerConfiguration analyzerConfiguration = null, List <string> metaReferences = null) { Logger = logger; _analyzerConfiguration = analyzerConfiguration; _metaReferences = metaReferences; Errors = new List <string>(); MissingMetaReferences = new List <string>(); }
public async Task TestWebApiWithReferencesUsingGenerator(string version) { var solutionPath = CopySolutionFolderToTemp("WebApiWithReferences.sln", tempDir); AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = false, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = false, ReferenceData = true, LoadBuildData = true, ElementAccess = true, MemberAccess = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); SolutionPort solutionPort = new SolutionPort(solutionPath); var resultEnumerator = analyzer.AnalyzeSolutionGeneratorAsync(solutionPath).GetAsyncEnumerator(); while (await resultEnumerator.MoveNextAsync()) { using var result = resultEnumerator.Current; PortCoreConfiguration projectConfiguration = new PortCoreConfiguration() { SolutionPath = solutionPath, ProjectPath = result.ProjectResult.ProjectFilePath, IsMockRun = false, UseDefaultRules = true, PortCode = true, PortProject = true, TargetVersions = new List <string> { version } }; solutionPort.RunProject(result, projectConfiguration); } var portSolutionResult = solutionPort.GenerateResults(); var testSolutionResult = GenerateSolutionResult(solutionPath, solutionPort.GetAnalysisResult(), portSolutionResult); ValidateWebApiWithReferences(testSolutionResult); }
public ProjectBuildHandler(ILogger logger, Project project, Compilation compilation, Compilation preportCompilation, AnalyzerConfiguration analyzerConfiguration = null) { Logger = logger; _analyzerConfiguration = analyzerConfiguration; this.Project = project; _projectPath = project.FilePath; this.Compilation = compilation; this.PrePortCompilation = preportCompilation; Errors = new List <string>(); MissingMetaReferences = new List <string>(); }
public WorkspaceBuilderHelper(ILogger logger, string workspacePath, AnalyzerConfiguration analyzerConfiguration = null) { this.Logger = logger; this.WorkspacePath = workspacePath; this.Projects = new List <ProjectAnalysisResult>(); this.FailedProjects = new List <ProjectAnalysisResult>(); this.DictAnalysisResult = new Dictionary <Guid, IAnalyzerResult>(); _analyzerConfiguration = analyzerConfiguration; _workspaceIncremental = new AdhocWorkspace(); _sb = new StringBuilder(); _writer = new StringWriter(_sb); _analyzerManager = GetAnalyzerManager(); _msBuildDetector = new MSBuildDetector(); }
public CodeContext(SemanticModel semanticModel, SyntaxTree syntaxTree, string workspacePath, string sourceFilePath, AnalyzerConfiguration analyzerConfiguration, ILogger logger) { SemanticModel = semanticModel; SyntaxTree = syntaxTree; WorkspacePath = workspacePath; AnalyzerConfiguration = analyzerConfiguration; SourceFilePath = sourceFilePath; Logger = logger; }
public async Task TestAnalysis() { string projectPath = string.Concat(GetTstPath(Path.Combine(new string[] { "Projects", "CodelyzerDummy", "CodelyzerDummy" })), ".csproj"); AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = true, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, LambdaMethods = true, DeclarationNodes = true, LocationData = true, ReferenceData = true, LoadBuildData = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); AnalyzerResult result = await analyzer.AnalyzeProject(projectPath); Assert.False(result.ProjectBuildResult.IsSyntaxAnalysis); Assert.True(result != null); // Extract the subject node var testClassRootNode = result.ProjectResult.SourceFileResults .First(s => s.FileFullPath.EndsWith("Class2.cs")) as UstNode; // Nested class is found Assert.AreEqual(1, testClassRootNode.AllClasses().Count(c => c.Identifier == "NestedClass")); // Chained method is found Assert.AreEqual(1, testClassRootNode.AllInvocationExpressions().Count(c => c.MethodName == "ChainedMethod")); // Constructor is found Assert.AreEqual(1, testClassRootNode.AllConstructors().Count); }
/// <summary> /// Initializes a new instance of Solution Port, analyzing the solution path using the provided config. /// WARNING: This constructor will rebuild and reanalyze the solution, which will have a performance impact. If you /// have an already analyzed solution, use another constructor /// </summary> /// <param name="solutionFilePath">Path to solution file</param> /// <param name="solutionConfiguration">Configuration for each project in solution to be built</param> public SolutionPort(string solutionFilePath, List <PortCoreConfiguration> solutionConfiguration, ILogger logger = null) { if (logger != null) { LogHelper.Logger = logger; } _portSolutionResult = new PortSolutionResult(solutionFilePath); SkipDownloadFiles = new ConcurrentDictionary <string, bool>(); _solutionPath = solutionFilePath; AnalyzerConfiguration analyzerConfiguration = new AnalyzerConfiguration(LanguageOptions.CSharp) { MetaDataSettings = new MetaDataSettings() { Annotations = true, DeclarationNodes = true, MethodInvocations = true, ReferenceData = true, LoadBuildData = true, InterfaceDeclarations = true, MemberAccess = true, ElementAccess = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(analyzerConfiguration, LogHelper.Logger); List <AnalyzerResult> analyzerResults = null; //We are building using references if (solutionConfiguration.Any(p => p.MetaReferences?.Any() == true)) { var currentReferences = solutionConfiguration.ToDictionary(s => s.ProjectPath, s => s.MetaReferences); var frameworkReferences = solutionConfiguration.ToDictionary(s => s.ProjectPath, s => s.FrameworkMetaReferences); analyzerResults = analyzer.AnalyzeSolution(solutionFilePath, frameworkReferences, currentReferences).Result; } else { analyzerResults = analyzer.AnalyzeSolution(solutionFilePath).Result; } _context = new MetricsContext(solutionFilePath, analyzerResults); InitSolutionRewriter(analyzerResults, solutionConfiguration); }
public ProjectBuildHandler(ILogger logger, Project project, AnalyzerConfiguration analyzerConfiguration = null) { Logger = logger; _analyzerConfiguration = analyzerConfiguration; CompilationOptions options = project.CompilationOptions; if (project.CompilationOptions is CSharpCompilationOptions) { /* * This is to fix the compilation errors related to : * Compile errors for assemblies which reference to mscorlib 2.0.5.0 (LINQPad 5.00.08) * https://forum.linqpad.net/discussion/856/compile-errors-for-assemblies-which-reference-to-mscorlib-2-0-5-0-linqpad-5-00-08 */ options = options.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); } this.Project = project.WithCompilationOptions(options); Errors = new List <string>(); }
public async Task TestNopCommerce() { string solutionPath = Directory.EnumerateFiles(tempDir, "nopCommerce.sln", SearchOption.AllDirectories).FirstOrDefault(); FileAssert.Exists(solutionPath); AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = false, OutputPath = @"/tmp/UnitTests" }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = false, ReferenceData = true, EnumDeclarations = true, StructDeclarations = true, InterfaceDeclarations = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); var results = (await analyzer.AnalyzeSolution(solutionPath)).ToList(); var enumDeclarations = results.Sum(r => r.ProjectResult.SourceFileResults.Where(s => s.AllEnumDeclarations().Count > 0).Sum(s => s.AllEnumDeclarations().Count)); var structDeclarations = results.Sum(r => r.ProjectResult.SourceFileResults.Where(s => s.AllStructDeclarations().Count > 0).Sum(s => s.AllStructDeclarations().Count)); var arrowClauseStatements = results.Sum(r => r.ProjectResult.SourceFileResults.Where(s => s.AllArrowExpressionClauses().Count > 0).Sum(s => s.AllArrowExpressionClauses().Count)); Assert.AreEqual(80, enumDeclarations); Assert.AreEqual(1, structDeclarations); Assert.AreEqual(2, arrowClauseStatements); results.ForEach(r => r.Dispose()); }
/// <summary> /// Initializes a new instance of SolutionRewriter, analyzing the solution path using the provided config. /// WARNING: This constructor will rebuild and reanalyze the solution, which will have a performance impact. If you /// have an already analyzed solution, use another constructor /// </summary> /// <param name="analyzerConfiguration">Configuration for code analyzer to be used (AnalyzerConfiguration)</param> /// <param name="solutionFilePath">Path to solution file</param> /// <param name="solutionConfiguration">Configuration for each project in solution to be built</param> public SolutionRewriter(string solutionFilePath, List <ProjectConfiguration> solutionConfiguration) { _solutionResult = new SolutionResult(); AnalyzerConfiguration analyzerConfiguration = new AnalyzerConfiguration(LanguageOptions.CSharp); analyzerConfiguration.MetaDataSettings = new MetaDataSettings() { Annotations = true, DeclarationNodes = true, MethodInvocations = true, ReferenceData = true, LoadBuildData = true, InterfaceDeclarations = true }; _rulesRewriters = new List <ProjectRewriter>(); CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(analyzerConfiguration, LogHelper.Logger); var analyzerResults = analyzer.AnalyzeSolution(solutionFilePath).Result; InitializeProjects(analyzerResults, solutionConfiguration); }
private async Task RunAgainWithChangedFile(string solutionPath, string projectPath, AnalyzerConfiguration configuration, CodeAnalyzer analyzer) { string projectFileContent = File.ReadAllText(projectPath); //Change the target to an invalid target to replicate an invalid msbuild installation File.WriteAllText(projectPath, projectFileContent.Replace(@"$(MSBuildBinPath)\Microsoft.CSharp.targets", @"InvalidTarget")); //Try without setting the flag, result should be null: AnalyzerResult result = (await analyzer.AnalyzeSolution(solutionPath)).FirstOrDefault(); Assert.Null(result); //Try with setting the flag, syntax tree should be returned configuration.AnalyzeFailedProjects = true; result = (await analyzer.AnalyzeSolution(solutionPath)).FirstOrDefault(); Assert.NotNull(result); Assert.True(result.ProjectBuildResult.IsSyntaxAnalysis); }
public async Task TestSampleWebApi() { string solutionPath = Directory.EnumerateFiles(tempDir, "SampleWebApi.sln", SearchOption.AllDirectories).FirstOrDefault(); FileAssert.Exists(solutionPath); string solutionDir = Directory.GetParent(solutionPath).FullName; AnalyzerConfiguration configuration = new AnalyzerConfiguration(LanguageOptions.CSharp) { ExportSettings = { GenerateJsonOutput = true, OutputPath = Path.Combine("/", "tmp", "UnitTests") }, MetaDataSettings = { LiteralExpressions = true, MethodInvocations = true, Annotations = true, DeclarationNodes = true, LocationData = false, ReferenceData = true, InterfaceDeclarations = true, GenerateBinFiles = true, LoadBuildData = true, ReturnStatements = true, InvocationArguments = true } }; CodeAnalyzer analyzer = CodeAnalyzerFactory.GetAnalyzer(configuration, NullLogger.Instance); AnalyzerResult result = (await analyzer.AnalyzeSolution(solutionPath)).FirstOrDefault(); Assert.True(result != null); Assert.False(result.ProjectBuildResult.IsSyntaxAnalysis); //Project has 16 nuget references and 19 framework/dll references: Assert.AreEqual(16, result.ProjectResult.ExternalReferences.NugetReferences.Count); Assert.AreEqual(19, result.ProjectResult.ExternalReferences.SdkReferences.Count); Assert.AreEqual(10, result.ProjectResult.SourceFiles.Count); var houseController = result.ProjectResult.SourceFileResults.Where(f => f.FilePath.EndsWith("HouseController.cs")).FirstOrDefault(); Assert.NotNull(houseController); var ihouseRepository = result.ProjectResult.SourceFileResults.Where(f => f.FilePath.EndsWith("IHouseRepository.cs")).FirstOrDefault(); Assert.NotNull(ihouseRepository); var blockStatements = houseController.AllBlockStatements(); var classDeclarations = houseController.AllClasses(); var expressionStatements = houseController.AllExpressions(); var invocationExpressions = houseController.AllInvocationExpressions(); var literalExpressions = houseController.AllLiterals(); var methodDeclarations = houseController.AllMethods(); var returnStatements = houseController.AllReturnStatements(); var annotations = houseController.AllAnnotations(); var namespaceDeclarations = houseController.AllNamespaces(); var objectCreationExpressions = houseController.AllObjectCreationExpressions(); var usingDirectives = houseController.AllUsingDirectives(); var interfaces = ihouseRepository.AllInterfaces(); var arguments = houseController.AllArguments(); Assert.AreEqual(7, blockStatements.Count); Assert.AreEqual(1, classDeclarations.Count); Assert.AreEqual(89, expressionStatements.Count); Assert.AreEqual(75, invocationExpressions.Count); Assert.AreEqual(14, literalExpressions.Count); Assert.AreEqual(6, methodDeclarations.Count); Assert.AreEqual(16, returnStatements.Count); Assert.AreEqual(17, annotations.Count); Assert.AreEqual(1, namespaceDeclarations.Count); Assert.AreEqual(0, objectCreationExpressions.Count); Assert.AreEqual(10, usingDirectives.Count); Assert.AreEqual(1, interfaces.Count); Assert.AreEqual(63, arguments.Count); var dllFiles = Directory.EnumerateFiles(Path.Combine(result.ProjectResult.ProjectRootPath, "bin"), "*.dll"); Assert.AreEqual(dllFiles.Count(), 16); await RunAgainWithChangedFile(solutionPath, result.ProjectBuildResult.ProjectPath, configuration, analyzer); }