public Coverage(string moduleOrDirectory, CoverageParameters parameters, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper) { _moduleOrAppDirectory = moduleOrDirectory; _includeFilters = parameters.IncludeFilters; _includeDirectories = parameters.IncludeDirectories ?? Array.Empty <string>(); _excludeFilters = parameters.ExcludeFilters; _excludedSourceFiles = parameters.ExcludedSourceFiles; _excludeAttributes = parameters.ExcludeAttributes; _includeTestAssembly = parameters.IncludeTestAssembly; _singleHit = parameters.SingleHit; _mergeWith = parameters.MergeWith; _useSourceLink = parameters.UseSourceLink; _doesNotReturnAttributes = parameters.DoesNotReturnAttributes; _logger = logger; _instrumentationHelper = instrumentationHelper; _fileSystem = fileSystem; _sourceRootTranslator = sourceRootTranslator; _cecilSymbolHelper = cecilSymbolHelper; _skipAutoProps = parameters.SkipAutoProps; _identifier = Guid.NewGuid().ToString(); _results = new List <InstrumenterResult>(); }
public Coverage(string module, string[] includeFilters, string[] includeDirectories, string[] excludeFilters, string[] excludedSourceFiles, string[] excludeAttributes, bool includeTestAssembly, bool singleHit, string mergeWith, bool useSourceLink, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem) { _module = module; _includeFilters = includeFilters; _includeDirectories = includeDirectories ?? Array.Empty <string>(); _excludeFilters = excludeFilters; _excludedSourceFiles = excludedSourceFiles; _excludeAttributes = excludeAttributes; _includeTestAssembly = includeTestAssembly; _singleHit = singleHit; _mergeWith = mergeWith; _useSourceLink = useSourceLink; _logger = logger; _instrumentationHelper = instrumentationHelper; _fileSystem = fileSystem; _identifier = Guid.NewGuid().ToString(); _results = new List <InstrumenterResult>(); }
public CoverageManager(CoverletSettings settings, IReporter[] reporters, ILogger logger, ICoverageWrapper coverageWrapper, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator) { // Store input vars Reporters = reporters; _coverageWrapper = coverageWrapper; // Coverage object _coverage = _coverageWrapper.CreateCoverage(settings, logger, instrumentationHelper, fileSystem, sourceRootTranslator); }
public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IInstrumentationHelper instrumentationHelper) { _identifier = prepareResult.Identifier; _module = prepareResult.Module; _mergeWith = prepareResult.MergeWith; _useSourceLink = prepareResult.UseSourceLink; _results = new List <InstrumenterResult>(prepareResult.Results); _logger = logger; _instrumentationHelper = instrumentationHelper; }
public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem) { _identifier = prepareResult.Identifier; _module = prepareResult.Module; _mergeWith = prepareResult.MergeWith; _useSourceLink = prepareResult.UseSourceLink; _pathOverrides = prepareResult.PathOverrides; _results = new List <InstrumenterResult>(prepareResult.Results); _logger = logger; _instrumentationHelper = instrumentationHelper; _fileSystem = fileSystem; }
public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator) { Identifier = prepareResult.Identifier; _moduleOrAppDirectory = prepareResult.ModuleOrDirectory; _parameters = prepareResult.Parameters; _results = new List <InstrumenterResult>(prepareResult.Results); _logger = logger; _instrumentationHelper = instrumentationHelper; _fileSystem = fileSystem; _sourceRootTranslator = sourceRootTranslator; }
public Coverage(CoveragePrepareResult prepareResult, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator) { _identifier = prepareResult.Identifier; _moduleOrAppDirectory = prepareResult.ModuleOrDirectory; _mergeWith = prepareResult.MergeWith; _useSourceLink = prepareResult.UseSourceLink; _results = new List <InstrumenterResult>(prepareResult.Results); _logger = logger; _instrumentationHelper = instrumentationHelper; _fileSystem = fileSystem; _sourceRootTranslator = sourceRootTranslator; }
public Coverage(string moduleOrDirectory, CoverageParameters parameters, ILogger logger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper) { _moduleOrAppDirectory = moduleOrDirectory; parameters.IncludeDirectories ??= Array.Empty <string>(); _logger = logger; _instrumentationHelper = instrumentationHelper; _parameters = parameters; _fileSystem = fileSystem; _sourceRootTranslator = sourceRootTranslator; _cecilSymbolHelper = cecilSymbolHelper; Identifier = Guid.NewGuid().ToString(); _results = new List <InstrumenterResult>(); }
public CoverageManager(CoverletSettings settings, TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger, ICoverageWrapper coverageWrapper, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator) : this(settings, settings.ReportFormats.Select(format => { var reporterFactory = new ReporterFactory(format); if (!reporterFactory.IsValidFormat()) { eqtTrace.Warning($"Invalid report format '{format}'"); return(null); } else { return(reporterFactory.CreateReporter()); } }).Where(r => r != null).ToArray(), new CoverletLogger(eqtTrace, logger), coverageWrapper, instrumentationHelper, fileSystem, sourceRootTranslator) { }
public Instrumenter( string module, string identifier, string[] excludeFilters, string[] includeFilters, string[] excludedFiles, string[] excludedAttributes, bool singleHit, ILogger logger, IInstrumentationHelper instrumentationHelper) { _module = module; _identifier = identifier; _excludeFilters = excludeFilters; _includeFilters = includeFilters; _excludedFilesHelper = new ExcludedFilesHelper(excludedFiles, logger); _excludedAttributes = excludedAttributes; _singleHit = singleHit; _isCoreLibrary = Path.GetFileNameWithoutExtension(_module) == "System.Private.CoreLib"; _logger = logger; _instrumentationHelper = instrumentationHelper; }
/// <summary> /// Creates a coverage object from given coverlet settings /// </summary> /// <param name="settings">Coverlet settings</param> /// <param name="coverletLogger">Coverlet logger</param> /// <returns>Coverage object</returns> public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator, ICecilSymbolHelper cecilSymbolHelper) { CoverageParameters parameters = new() { IncludeFilters = settings.IncludeFilters, IncludeDirectories = settings.IncludeDirectories, ExcludeFilters = settings.ExcludeFilters, ExcludedSourceFiles = settings.ExcludeSourceFiles, ExcludeAttributes = settings.ExcludeAttributes, IncludeTestAssembly = settings.IncludeTestAssembly, SingleHit = settings.SingleHit, MergeWith = settings.MergeWith, UseSourceLink = settings.UseSourceLink, SkipAutoProps = settings.SkipAutoProps, DoesNotReturnAttributes = settings.DoesNotReturnAttributes, DeterministicReport = settings.DeterministicReport }; return(new Coverage( settings.TestModule, parameters, coverletLogger, instrumentationHelper, fileSystem, sourceRootTranslator, cecilSymbolHelper)); }
/// <summary> /// Creates a coverage object from given coverlet settings /// </summary> /// <param name="settings">Coverlet settings</param> /// <param name="coverletLogger">Coverlet logger</param> /// <returns>Coverage object</returns> public Coverage CreateCoverage(CoverletSettings settings, ILogger coverletLogger, IInstrumentationHelper instrumentationHelper, IFileSystem fileSystem, ISourceRootTranslator sourceRootTranslator) { return(new Coverage( settings.TestModule, settings.IncludeFilters, settings.IncludeDirectories, settings.ExcludeFilters, settings.ExcludeSourceFiles, settings.ExcludeAttributes, settings.IncludeTestAssembly, settings.SingleHit, settings.MergeWith, settings.UseSourceLink, coverletLogger, instrumentationHelper, fileSystem, sourceRootTranslator)); }
public override bool Execute() { try { Console.WriteLine("\nCalculating coverage result..."); IFileSystem fileSystem = ServiceProvider.GetService <IFileSystem>(); if (InstrumenterState is null || !fileSystem.Exists(InstrumenterState.ItemSpec)) { _logger.LogError("Result of instrumentation task not found"); return(false); } Coverage coverage = null; using (Stream instrumenterStateStream = fileSystem.NewFileStream(InstrumenterState.ItemSpec, FileMode.Open)) { IInstrumentationHelper instrumentationHelper = ServiceProvider.GetService <IInstrumentationHelper>(); // Task.Log is teared down after a task and thus the new MSBuildLogger must be passed to the InstrumentationHelper // https://github.com/microsoft/msbuild/issues/5153 instrumentationHelper.SetLogger(_logger); coverage = new Coverage(CoveragePrepareResult.Deserialize(instrumenterStateStream), _logger, ServiceProvider.GetService <IInstrumentationHelper>(), fileSystem, ServiceProvider.GetService <ISourceRootTranslator>()); } try { fileSystem.Delete(InstrumenterState.ItemSpec); } catch (Exception ex) { // We don't want to block coverage for I/O errors _logger.LogWarning($"Exception during instrument state deletion, file name '{InstrumenterState.ItemSpec}' exception message '{ex.Message}'"); } CoverageResult result = coverage.GetCoverageResult(); string directory = Path.GetDirectoryName(Output); if (directory == string.Empty) { directory = Directory.GetCurrentDirectory(); } else if (!Directory.Exists(directory)) { Directory.CreateDirectory(directory); } string[] formats = OutputFormat.Split(','); var coverageReportPaths = new List <ITaskItem>(formats.Length); ISourceRootTranslator sourceRootTranslator = ServiceProvider.GetService <ISourceRootTranslator>(); foreach (string format in formats) { IReporter reporter = new ReporterFactory(format).CreateReporter(); if (reporter == null) { throw new Exception($"Specified output format '{format}' is not supported"); } if (reporter.OutputType == ReporterOutputType.Console) { // Output to console Console.WriteLine(" Outputting results to console"); Console.WriteLine(reporter.Report(result, sourceRootTranslator)); } else { ReportWriter writer = new(CoverletMultiTargetFrameworksCurrentTFM, directory, Output, reporter, fileSystem, ServiceProvider.GetService <IConsole>(), result, sourceRootTranslator); string path = writer.WriteReport(); var metadata = new Dictionary <string, string> { ["Format"] = format }; coverageReportPaths.Add(new TaskItem(path, metadata)); } } ReportItems = coverageReportPaths.ToArray(); var thresholdTypeFlagQueue = new Queue <ThresholdTypeFlags>(); foreach (string thresholdType in ThresholdType.Split(',').Select(t => t.Trim())) { if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Line); } else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Branch); } else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Method); } } var thresholdTypeFlagValues = new Dictionary <ThresholdTypeFlags, double>(); if (Threshold.Contains(',')) { IEnumerable <string> thresholdValues = Threshold.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()); if (thresholdValues.Count() != thresholdTypeFlagQueue.Count) { throw new Exception($"Threshold type flag count ({thresholdTypeFlagQueue.Count}) and values count ({thresholdValues.Count()}) doesn't match"); } foreach (string threshold in thresholdValues) { if (double.TryParse(threshold, out double value)) { thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = value; } else { throw new Exception($"Invalid threshold value must be numeric"); } } } else { double thresholdValue = double.Parse(Threshold); while (thresholdTypeFlagQueue.Any()) { thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = thresholdValue; } } ThresholdStatistic thresholdStat = ThresholdStatistic.Minimum; if (ThresholdStat.Equals("average", StringComparison.OrdinalIgnoreCase)) { thresholdStat = ThresholdStatistic.Average; } else if (ThresholdStat.Equals("total", StringComparison.OrdinalIgnoreCase)) { thresholdStat = ThresholdStatistic.Total; } var coverageTable = new ConsoleTable("Module", "Line", "Branch", "Method"); var summary = new CoverageSummary(); CoverageDetails linePercentCalculation = summary.CalculateLineCoverage(result.Modules); CoverageDetails branchPercentCalculation = summary.CalculateBranchCoverage(result.Modules); CoverageDetails methodPercentCalculation = summary.CalculateMethodCoverage(result.Modules); double totalLinePercent = linePercentCalculation.Percent; double totalBranchPercent = branchPercentCalculation.Percent; double totalMethodPercent = methodPercentCalculation.Percent; double averageLinePercent = linePercentCalculation.AverageModulePercent; double averageBranchPercent = branchPercentCalculation.AverageModulePercent; double averageMethodPercent = methodPercentCalculation.AverageModulePercent; foreach (KeyValuePair <string, Documents> module in result.Modules) { double linePercent = summary.CalculateLineCoverage(module.Value).Percent; double branchPercent = summary.CalculateBranchCoverage(module.Value).Percent; double methodPercent = summary.CalculateMethodCoverage(module.Value).Percent; coverageTable.AddRow(Path.GetFileNameWithoutExtension(module.Key), $"{InvariantFormat(linePercent)}%", $"{InvariantFormat(branchPercent)}%", $"{InvariantFormat(methodPercent)}%"); } Console.WriteLine(); Console.WriteLine(coverageTable.ToStringAlternative()); coverageTable.Columns.Clear(); coverageTable.Rows.Clear(); coverageTable.AddColumn(new[] { "", "Line", "Branch", "Method" }); coverageTable.AddRow("Total", $"{InvariantFormat(totalLinePercent)}%", $"{InvariantFormat(totalBranchPercent)}%", $"{InvariantFormat(totalMethodPercent)}%"); coverageTable.AddRow("Average", $"{InvariantFormat(averageLinePercent)}%", $"{InvariantFormat(averageBranchPercent)}%", $"{InvariantFormat(averageMethodPercent)}%"); Console.WriteLine(coverageTable.ToStringAlternative()); ThresholdTypeFlags thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdStat); if (thresholdTypeFlags != ThresholdTypeFlags.None) { var exceptionMessageBuilder = new StringBuilder(); if ((thresholdTypeFlags & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine( $"The {thresholdStat.ToString().ToLower()} line coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Line]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine( $"The {thresholdStat.ToString().ToLower()} branch coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Branch]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { exceptionMessageBuilder.AppendLine( $"The {thresholdStat.ToString().ToLower()} method coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Method]}"); } throw new Exception(exceptionMessageBuilder.ToString()); } } catch (Exception ex) { _logger.LogError(ex); return(false); } return(true); }