Skip to content

Changed to calculate based on the average coverage of the modules #479

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 7 commits into from
Jul 27, 2019
Merged

Changed to calculate based on the average coverage of the modules #479

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
c7f0179
[Bug fix]Changed to calculate based on the average coverage of the mo…
Jun 27, 2019
4c1b6a0
[Bug fix]Changed to calculate based on the average coverage of the mo…
Jun 27, 2019
2744f8e
[Bug fix] Added tests, refactoring and changed number alignment (tone…
Jun 28, 2019
492ecf8
[Bug fix] Clean code and reverted ConsoleTable (aligment), (tonerdo#346)
Jun 29, 2019
91e5a3c
[Bug fix] Refactoring: configuration data called inside the construct…
Jul 1, 2019
6522779
[Bug fix] Format code (tonerdo#346)
Jul 2, 2019
be3a72b
[Bug fix] Format code (tonerdo#346)
Jul 2, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 12 additions & 4 deletions src/coverlet.console/Program.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -168,9 +168,17 @@ static int Main(string[] args)
var summary = new CoverageSummary();
int numModules = result.Modules.Count;

var totalLinePercent = summary.CalculateLineCoverage(result.Modules).Percent;
var totalBranchPercent = summary.CalculateBranchCoverage(result.Modules).Percent;
var totalMethodPercent = summary.CalculateMethodCoverage(result.Modules).Percent;
var linePercentCalculation = summary.CalculateLineCoverage(result.Modules);
var branchPercentCalculation = summary.CalculateBranchCoverage(result.Modules);
var methodPercentCalculation = summary.CalculateMethodCoverage(result.Modules);

var totalLinePercent = linePercentCalculation.Percent;
var totalBranchPercent = branchPercentCalculation.Percent;
var totalMethodPercent = methodPercentCalculation.Percent;

var averageLinePercent = linePercentCalculation.AverageModulePercent;
var averageBranchPercent = branchPercentCalculation.AverageModulePercent;
var averageMethodPercent = methodPercentCalculation.AverageModulePercent;

foreach (var _module in result.Modules)
{
Expand All @@ -188,7 +196,7 @@ static int Main(string[] args)

coverageTable.AddColumn(new[] { "", "Line", "Branch", "Method" });
coverageTable.AddRow("Total", $"{totalLinePercent}%", $"{totalBranchPercent}%", $"{totalMethodPercent}%");
coverageTable.AddRow("Average", $"{totalLinePercent / numModules}%", $"{totalBranchPercent / numModules}%", $"{totalMethodPercent / numModules}%");
coverageTable.AddRow("Average", $"{averageLinePercent}%", $"{averageBranchPercent}%", $"{averageMethodPercent}%");

logger.LogInformation(coverageTable.ToStringAlternative());

Expand Down
7 changes: 7 additions & 0 deletions src/coverlet.core/CoverageDetails.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,8 +4,15 @@ namespace Coverlet.Core
{
public class CoverageDetails
{
private double _averageModulePercent;
public double Covered { get; internal set; }
public int Total { get; internal set; }
public double AverageModulePercent
{
get { return Math.Floor(_averageModulePercent * 100) / 100; }
internal set { _averageModulePercent = value; }
}

public double Percent => Total == 0 ? 100D : Math.Floor((Covered / Total) * 10000) / 100;
}
}
32 changes: 12 additions & 20 deletions src/coverlet.core/CoverageResult.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -170,9 +170,9 @@ public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summar
{
foreach (var module in Modules)
{
var line = summary.CalculateLineCoverage(module.Value).Percent;
var branch = summary.CalculateBranchCoverage(module.Value).Percent;
var method = summary.CalculateMethodCoverage(module.Value).Percent;
double line = summary.CalculateLineCoverage(module.Value).Percent;
double branch = summary.CalculateBranchCoverage(module.Value).Percent;
double method = summary.CalculateMethodCoverage(module.Value).Percent;

if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None)
{
Expand All @@ -196,42 +196,34 @@ public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summar
break;
case ThresholdStatistic.Average:
{
double line = 0;
double branch = 0;
double method = 0;
int numModules = Modules.Count;

foreach (var module in Modules)
{
line += summary.CalculateLineCoverage(module.Value).Percent;
branch += summary.CalculateBranchCoverage(module.Value).Percent;
method += summary.CalculateMethodCoverage(module.Value).Percent;
}
double line = summary.CalculateLineCoverage(Modules).AverageModulePercent;
double branch = summary.CalculateBranchCoverage(Modules).AverageModulePercent;
double method = summary.CalculateMethodCoverage(Modules).AverageModulePercent;

if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None)
{
if ((line / numModules) < threshold)
if (line < threshold)
thresholdTypeFlags |= ThresholdTypeFlags.Line;
}

if ((thresholdTypes & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None)
{
if ((branch / numModules) < threshold)
if (branch < threshold)
thresholdTypeFlags |= ThresholdTypeFlags.Branch;
}

if ((thresholdTypes & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None)
{
if ((method / numModules) < threshold)
if (method < threshold)
thresholdTypeFlags |= ThresholdTypeFlags.Method;
}
}
break;
case ThresholdStatistic.Total:
{
var line = summary.CalculateLineCoverage(Modules).Percent;
var branch = summary.CalculateBranchCoverage(Modules).Percent;
var method = summary.CalculateMethodCoverage(Modules).Percent;
double line = summary.CalculateLineCoverage(Modules).Percent;
double branch = summary.CalculateBranchCoverage(Modules).Percent;
double method = summary.CalculateMethodCoverage(Modules).Percent;

if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None)
{
Expand Down
9 changes: 9 additions & 0 deletions src/coverlet.core/CoverageSummary.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,12 +53,15 @@ public CoverageDetails CalculateLineCoverage(Documents documents)
public CoverageDetails CalculateLineCoverage(Modules modules)
{
var details = new CoverageDetails();
var accumPercent = 0.0D;
foreach (var module in modules)
{
var moduleCoverage = CalculateLineCoverage(module.Value);
details.Covered += moduleCoverage.Covered;
details.Total += moduleCoverage.Total;
accumPercent += moduleCoverage.Percent;
}
details.AverageModulePercent = accumPercent / modules.Count;
return details;
}

Expand Down Expand Up @@ -149,12 +152,15 @@ public CoverageDetails CalculateBranchCoverage(Documents documents)
public CoverageDetails CalculateBranchCoverage(Modules modules)
{
var details = new CoverageDetails();
var accumPercent = 0.0D;
foreach (var module in modules)
{
var moduleCoverage = CalculateBranchCoverage(module.Value);
details.Covered += moduleCoverage.Covered;
details.Total += moduleCoverage.Total;
accumPercent += moduleCoverage.Percent;
}
details.AverageModulePercent = accumPercent / modules.Count;
return details;
}

Expand Down Expand Up @@ -206,12 +212,15 @@ public CoverageDetails CalculateMethodCoverage(Documents documents)
public CoverageDetails CalculateMethodCoverage(Modules modules)
{
var details = new CoverageDetails();
var accumPercent = 0.0D;
foreach (var module in modules)
{
var moduleCoverage = CalculateMethodCoverage(module.Value);
details.Covered += moduleCoverage.Covered;
details.Total += moduleCoverage.Total;
accumPercent += moduleCoverage.Percent;
}
details.AverageModulePercent = accumPercent / modules.Count;
return details;
}
}
Expand Down
116 changes: 105 additions & 11 deletions test/coverlet.core.tests/CoverageSummaryTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,12 +10,14 @@ namespace Coverlet.Core.Tests
{
public class CoverageSummaryTests
{
private Modules _modules;
private Modules _averageCalculationSingleModule;
private Modules _averageCalculationMultiModule;
private Modules _moduleArithmeticPrecision;

public CoverageSummaryTests()
{
SetupData();
SetupDataSingleModule();
SetupDataMultipleModule();
SetupDataForArithmeticPrecision();
}

Expand Down Expand Up @@ -50,7 +52,7 @@ private void SetupDataForArithmeticPrecision()
_moduleArithmeticPrecision.Add("module", documents);
}

private void SetupData()
private void SetupDataSingleModule()
{
Lines lines = new Lines();
lines.Add(1, 1);
Expand All @@ -71,58 +73,148 @@ private void SetupData()
Documents documents = new Documents();
documents.Add("doc.cs", classes);

_modules = new Modules();
_modules.Add("module", documents);
_averageCalculationSingleModule = new Modules();
_averageCalculationSingleModule.Add("module", documents);
}

private void SetupDataMultipleModule()
{
Lines lines = new Lines
{
{ 1, 1 }, // covered
{ 2, 0 }, // not covered
{ 3, 0 } // not covered
};

Branches branches = new Branches
{
new BranchInfo { Line = 1, Hits = 1, Offset = 1, Path = 0, Ordinal = 1 }, // covered
new BranchInfo { Line = 1, Hits = 1, Offset = 1, Path = 1, Ordinal = 2 }, // covered
new BranchInfo { Line = 1, Hits = 0, Offset = 1, Path = 1, Ordinal = 2 } // not covered
};

Methods methods = new Methods();
string[] methodString = {
"System.Void Coverlet.Core.Tests.CoverageSummaryTests::TestCalculateSummary()", // covered
"System.Void Coverlet.Core.Tests.CoverageSummaryTests::TestAditionalCalculateSummary()" // not covered
};
methods.Add(methodString[0], new Method());
methods[methodString[0]].Lines = lines;
methods[methodString[0]].Branches = branches;

methods.Add(methodString[1], new Method());
methods[methodString[1]].Lines = new Lines
{
{ 1, 0 } // not covered
};

Classes classes = new Classes
{
{ "Coverlet.Core.Tests.CoverageSummaryTests", methods }
};

Documents documents = new Documents
{
{ "doc.cs", classes }
};

_averageCalculationMultiModule = new Modules
{
{ "module", _averageCalculationSingleModule["module"] },
{ "aditionalModule", documents }
};
}

[Fact]
public void TestCalculateLineCoverage()
public void TestCalculateLineCoverage_SingleModule()
{
CoverageSummary summary = new CoverageSummary();

var module = _modules.First();
var module = _averageCalculationSingleModule.First();
var document = module.Value.First();
var @class = document.Value.First();
var method = @class.Value.First();

Assert.Equal(50, summary.CalculateLineCoverage(_averageCalculationSingleModule).AverageModulePercent);
Assert.Equal(50, summary.CalculateLineCoverage(module.Value).Percent);
Assert.Equal(50, summary.CalculateLineCoverage(document.Value).Percent);
Assert.Equal(50, summary.CalculateLineCoverage(@class.Value).Percent);
Assert.Equal(50, summary.CalculateLineCoverage(method.Value.Lines).Percent);
}

[Fact]
public void TestCalculateBranchCoverage()
public void TestCalculateLineCoverage_MultiModule()
{
CoverageSummary summary = new CoverageSummary();
var documentsFirstModule = _averageCalculationMultiModule["module"];
var documentsSecondModule = _averageCalculationMultiModule["aditionalModule"];

Assert.Equal(37.5, summary.CalculateLineCoverage(_averageCalculationMultiModule).AverageModulePercent);
Assert.Equal(50, summary.CalculateLineCoverage(documentsFirstModule.First().Value).Percent);

Assert.Equal(33.33, summary.CalculateLineCoverage(documentsSecondModule.First().Value.First().Value.ElementAt(0).Value.Lines).Percent); // covered 1 of 3
Assert.Equal(0, summary.CalculateLineCoverage(documentsSecondModule.First().Value.First().Value.ElementAt(1).Value.Lines).Percent); // covered 0 of 1
Assert.Equal(25, summary.CalculateLineCoverage(documentsSecondModule.First().Value).Percent); // covered 1 of 4 lines
}

[Fact]
public void TestCalculateBranchCoverage_SingleModule()
{
CoverageSummary summary = new CoverageSummary();

var module = _modules.First();
var module = _averageCalculationSingleModule.First();
var document = module.Value.First();
var @class = document.Value.First();
var method = @class.Value.First();

Assert.Equal(100, summary.CalculateBranchCoverage(_averageCalculationSingleModule).AverageModulePercent);
Assert.Equal(100, summary.CalculateBranchCoverage(module.Value).Percent);
Assert.Equal(100, summary.CalculateBranchCoverage(document.Value).Percent);
Assert.Equal(100, summary.CalculateBranchCoverage(@class.Value).Percent);
Assert.Equal(100, summary.CalculateBranchCoverage(method.Value.Branches).Percent);
}

[Fact]
public void TestCalculateMethodCoverage()
public void TestCalculateBranchCoverage_MultiModule()
{
CoverageSummary summary = new CoverageSummary();
var documentsFirstModule = _averageCalculationMultiModule["module"];
var documentsSecondModule = _averageCalculationMultiModule["aditionalModule"];

var module = _modules.First();
Assert.Equal(83.33, summary.CalculateBranchCoverage(_averageCalculationMultiModule).AverageModulePercent);
Assert.Equal(100, summary.CalculateBranchCoverage(documentsFirstModule.First().Value).Percent);
Assert.Equal(66.66, summary.CalculateBranchCoverage(documentsSecondModule.First().Value).Percent);
}

[Fact]
public void TestCalculateMethodCoverage_SingleModule()
{
CoverageSummary summary = new CoverageSummary();

var module = _averageCalculationSingleModule.First();
var document = module.Value.First();
var @class = document.Value.First();
var method = @class.Value.First();

Assert.Equal(100, summary.CalculateMethodCoverage(_averageCalculationSingleModule).AverageModulePercent);
Assert.Equal(100, summary.CalculateMethodCoverage(module.Value).Percent);
Assert.Equal(100, summary.CalculateMethodCoverage(document.Value).Percent);
Assert.Equal(100, summary.CalculateMethodCoverage(@class.Value).Percent);
Assert.Equal(100, summary.CalculateMethodCoverage(method.Value.Lines).Percent);
}

[Fact]
public void TestCalculateMethodCoverage_MultiModule()
{
CoverageSummary summary = new CoverageSummary();
var documentsFirstModule = _averageCalculationMultiModule["module"];
var documentsSecondModule = _averageCalculationMultiModule["aditionalModule"];

Assert.Equal(75, summary.CalculateMethodCoverage(_averageCalculationMultiModule).AverageModulePercent);
Assert.Equal(100, summary.CalculateMethodCoverage(documentsFirstModule.First().Value).Percent);
Assert.Equal(50, summary.CalculateMethodCoverage(documentsSecondModule.First().Value).Percent);
}

[Fact]
public void TestCalculateLineCoveragePercentage_ArithmeticPrecisionCheck()
{
Expand All @@ -133,6 +225,7 @@ public void TestCalculateLineCoveragePercentage_ArithmeticPrecisionCheck()
var @class = document.Value.First();
var method = @class.Value.First();

Assert.Equal(16.66, summary.CalculateLineCoverage(_moduleArithmeticPrecision).AverageModulePercent);
Assert.Equal(16.66, summary.CalculateLineCoverage(module.Value).Percent);
Assert.Equal(16.66, summary.CalculateLineCoverage(document.Value).Percent);
Assert.Equal(16.66, summary.CalculateLineCoverage(@class.Value).Percent);
Expand All @@ -149,6 +242,7 @@ public void TestCalculateBranchCoveragePercentage_ArithmeticPrecisionCheck()
var @class = document.Value.First();
var method = @class.Value.First();

Assert.Equal(16.66, summary.CalculateBranchCoverage(_moduleArithmeticPrecision).AverageModulePercent);
Assert.Equal(16.66, summary.CalculateBranchCoverage(module.Value).Percent);
Assert.Equal(16.66, summary.CalculateBranchCoverage(document.Value).Percent);
Assert.Equal(16.66, summary.CalculateBranchCoverage(@class.Value).Percent);
Expand Down