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);
}
