From b70bd62ac20730ed6ee91c3aad90808fa2b7be27 Mon Sep 17 00:00:00 2001 From: Arun Subramanian Date: Sat, 27 Apr 2019 10:05:43 -0700 Subject: [PATCH 1/2] Add option to specify multiple threshold values for each threshold types. + For single threshold value behavior will be same as present, i.e same threshold values is used to check against specified threshold types. Otherwise parse the value in the same order as the threshold type. Usage (1). /p:Threshold=\"80,100,70\" /p:ThresholdType=\"line,branch,method\" (2). /p:Threshold=90 /p:ThresholdType=\"line,branch,method\" (3). /p:Threshold=\"80,90\" /p:ThresholdType=\"branch,method\" --- src/coverlet.console/Program.cs | 41 ++++- src/coverlet.core/CoverageResult.cs | 22 +-- src/coverlet.core/Properties/AssemblyInfo.cs | 2 +- .../CoverageResultTask.cs | 46 ++++- .../CoverageResultTests.cs | 160 ++++++++++++++++++ 5 files changed, 246 insertions(+), 25 deletions(-) create mode 100644 test/coverlet.core.tests/CoverageResultTests.cs diff --git a/src/coverlet.console/Program.cs b/src/coverlet.console/Program.cs index 580838a56..ddebc82ba 100644 --- a/src/coverlet.console/Program.cs +++ b/src/coverlet.console/Program.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.IO; +using System.Linq; using System.Text; using System.Threading.Tasks; using ConsoleTables; @@ -14,6 +15,8 @@ namespace Coverlet.Console { + using ThresholdTypeFlagValues = Dictionary; + class Program { static int Main(string[] args) @@ -90,7 +93,6 @@ static int Main(string[] args) process.WaitForExit(); var dOutput = output.HasValue() ? output.Value() : Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar.ToString(); - var dThreshold = threshold.HasValue() ? double.Parse(threshold.Value()) : 0; var dThresholdTypes = thresholdTypes.HasValue() ? thresholdTypes.Values : new List(new string[] { "line", "branch", "method" }); var dThresholdStat = thresholdStat.HasValue() ? Enum.Parse(thresholdStat.Value(), true) : Enum.Parse("minimum", true); @@ -135,20 +137,47 @@ static int Main(string[] args) } var thresholdTypeFlags = ThresholdTypeFlags.None; - + var thresholdTypeFlagQueue = new Queue(); foreach (var thresholdType in dThresholdTypes) { if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Line; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Line); } else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Branch; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Branch); } else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Method; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Method); + } + } + + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues(); + if (threshold.HasValue() && threshold.Value().Contains(',')) + { + var thresholdValues = threshold.Value().Split(',').Select(t => t.Trim()); + if (thresholdValues.Count() != thresholdTypeFlagQueue.Count()) + { + throw new Exception($"Threshold type flag count ({thresholdTypeFlagQueue.Count()}) and values count ({thresholdValues.Count()}) doesnt match"); + } + + foreach (var _threshold in thresholdValues) + { + thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = double.Parse(_threshold); + } + } + else + { + double thresholdValue = threshold.HasValue() ? double.Parse(threshold.Value()) : 0; + + while (thresholdTypeFlagQueue.Any()) + { + thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = thresholdValue; } } @@ -180,23 +209,23 @@ static int Main(string[] args) logger.LogInformation(coverageTable.ToStringAlternative()); - thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, dThreshold, thresholdTypeFlags, dThresholdStat); + thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, dThresholdStat); if (thresholdTypeFlags != ThresholdTypeFlags.None) { var exceptionMessageBuilder = new StringBuilder(); if ((thresholdTypeFlags & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { - exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} line coverage is below the specified {dThreshold}"); + exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} line coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Line]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { - exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} branch coverage is below the specified {dThreshold}"); + exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} branch coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Branch]}"); } if ((thresholdTypeFlags & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { - exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} method coverage is below the specified {dThreshold}"); + exceptionMessageBuilder.AppendLine($"The {dThresholdStat.ToString().ToLower()} method coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Method]}"); } throw new Exception(exceptionMessageBuilder.ToString()); diff --git a/src/coverlet.core/CoverageResult.cs b/src/coverlet.core/CoverageResult.cs index b6c02eade..2cb11d518 100644 --- a/src/coverlet.core/CoverageResult.cs +++ b/src/coverlet.core/CoverageResult.cs @@ -8,6 +8,8 @@ namespace Coverlet.Core { + using ThresholdTypeFlagValues = Dictionary; + public class BranchInfo { public int Line { get; set; } @@ -161,7 +163,7 @@ private bool IsAsyncStateMachineMethod(string method) return false; } - public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summary, double threshold, ThresholdTypeFlags thresholdTypes, ThresholdStatistic thresholdStat) + public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summary, ThresholdTypeFlagValues thresholdTypeFlagValues, ThresholdTypeFlags thresholdTypes, ThresholdStatistic thresholdStat) { var thresholdTypeFlags = ThresholdTypeFlags.None; switch (thresholdStat) @@ -176,19 +178,19 @@ public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summar if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { - if (line < threshold) + if (line < thresholdTypeFlagValues[ThresholdTypeFlags.Line]) thresholdTypeFlags |= ThresholdTypeFlags.Line; } if ((thresholdTypes & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { - if (branch < threshold) + if (branch < thresholdTypeFlagValues[ThresholdTypeFlags.Branch]) thresholdTypeFlags |= ThresholdTypeFlags.Branch; } if ((thresholdTypes & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { - if (method < threshold) + if (method < thresholdTypeFlagValues[ThresholdTypeFlags.Method]) thresholdTypeFlags |= ThresholdTypeFlags.Method; } } @@ -210,19 +212,19 @@ public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summar if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { - if ((line / numModules) < threshold) + if ((line / numModules) < thresholdTypeFlagValues[ThresholdTypeFlags.Line]) thresholdTypeFlags |= ThresholdTypeFlags.Line; } if ((thresholdTypes & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { - if ((branch / numModules) < threshold) + if ((branch / numModules) < thresholdTypeFlagValues[ThresholdTypeFlags.Branch]) thresholdTypeFlags |= ThresholdTypeFlags.Branch; } if ((thresholdTypes & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { - if ((method / numModules) < threshold) + if ((method / numModules) < thresholdTypeFlagValues[ThresholdTypeFlags.Method]) thresholdTypeFlags |= ThresholdTypeFlags.Method; } } @@ -235,19 +237,19 @@ public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summar if ((thresholdTypes & ThresholdTypeFlags.Line) != ThresholdTypeFlags.None) { - if (line < threshold) + if (line < thresholdTypeFlagValues[ThresholdTypeFlags.Line]) thresholdTypeFlags |= ThresholdTypeFlags.Line; } if ((thresholdTypes & ThresholdTypeFlags.Branch) != ThresholdTypeFlags.None) { - if (branch < threshold) + if (branch < thresholdTypeFlagValues[ThresholdTypeFlags.Branch]) thresholdTypeFlags |= ThresholdTypeFlags.Branch; } if ((thresholdTypes & ThresholdTypeFlags.Method) != ThresholdTypeFlags.None) { - if (method < threshold) + if (method < thresholdTypeFlagValues[ThresholdTypeFlags.Method]) thresholdTypeFlags |= ThresholdTypeFlags.Method; } } diff --git a/src/coverlet.core/Properties/AssemblyInfo.cs b/src/coverlet.core/Properties/AssemblyInfo.cs index cce4d926d..2396fe638 100644 --- a/src/coverlet.core/Properties/AssemblyInfo.cs +++ b/src/coverlet.core/Properties/AssemblyInfo.cs @@ -1,4 +1,4 @@ -[assembly: System.Reflection.AssemblyKeyFileAttribute("coverlet.core.snk")] +[assembly: System.Reflection.AssemblyKeyFile("coverlet.core.snk")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Coverlet.Core.Tests,PublicKey=" + "0024000004800000940000000602000000240000525341310004000001000100757cf9291d78a8" + "2e5bb58a827a3c46c2f959318327ad30d1b52e918321ffbd847fb21565b8576d2a3a24562a93e8" + diff --git a/src/coverlet.msbuild.tasks/CoverageResultTask.cs b/src/coverlet.msbuild.tasks/CoverageResultTask.cs index 4fe1c323c..f3325d415 100644 --- a/src/coverlet.msbuild.tasks/CoverageResultTask.cs +++ b/src/coverlet.msbuild.tasks/CoverageResultTask.cs @@ -1,4 +1,5 @@ using System; +using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; @@ -11,11 +12,13 @@ namespace Coverlet.MSbuild.Tasks { + using ThresholdTypeFlagValues = Dictionary; + public class CoverageResultTask : Task { private string _output; private string _format; - private double _threshold; + private string _threshold; private string _thresholdType; private string _thresholdStat; private MSBuildLogger _logger; @@ -35,7 +38,7 @@ public string OutputFormat } [Required] - public double Threshold + public string Threshold { get { return _threshold; } set { _threshold = value; } @@ -108,24 +111,51 @@ public override bool Execute() } var thresholdTypeFlags = ThresholdTypeFlags.None; - var thresholdStat = ThresholdStatistic.Minimum; - + var thresholdTypeFlagQueue = new Queue(); foreach (var thresholdType in _thresholdType.Split(',').Select(t => t.Trim())) { if (thresholdType.Equals("line", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Line; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Line); } else if (thresholdType.Equals("branch", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Branch; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Branch); } else if (thresholdType.Equals("method", StringComparison.OrdinalIgnoreCase)) { thresholdTypeFlags |= ThresholdTypeFlags.Method; + thresholdTypeFlagQueue.Enqueue(ThresholdTypeFlags.Method ); } } + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues(); + if (_threshold.Contains(',')) + { + var thresholdValues = _threshold.Split(',').Select(t => t.Trim()); + if(thresholdValues.Count() != thresholdTypeFlagQueue.Count()) + { + throw new Exception($"Threshold type flag count ({thresholdTypeFlagQueue.Count()}) and values count ({thresholdValues.Count()}) doesnt match"); + } + + foreach (var threshold in thresholdValues) + { + thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = double.Parse(threshold); + } + } + else + { + double thresholdValue = double.Parse(_threshold); + + while (thresholdTypeFlagQueue.Any()) + { + thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = thresholdValue; + } + } + + var thresholdStat = ThresholdStatistic.Minimum; if (_thresholdStat.Equals("average", StringComparison.OrdinalIgnoreCase)) { thresholdStat = ThresholdStatistic.Average; @@ -164,23 +194,23 @@ public override bool Execute() Console.WriteLine(coverageTable.ToStringAlternative()); - thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, _threshold, thresholdTypeFlags, thresholdStat); + thresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, 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 {_threshold}"); + 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 {_threshold}"); + 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 {_threshold}"); + exceptionMessageBuilder.AppendLine($"The {thresholdStat.ToString().ToLower()} method coverage is below the specified {thresholdTypeFlagValues[ThresholdTypeFlags.Method]}"); } throw new Exception(exceptionMessageBuilder.ToString()); diff --git a/test/coverlet.core.tests/CoverageResultTests.cs b/test/coverlet.core.tests/CoverageResultTests.cs new file mode 100644 index 000000000..f202ed875 --- /dev/null +++ b/test/coverlet.core.tests/CoverageResultTests.cs @@ -0,0 +1,160 @@ +using System; +using System.Collections.Generic; +using System.Linq; + +using Coverlet.Core; +using Coverlet.Core.Enums; +using Moq; +using Xunit; + +namespace Coverlet.Core.Tests +{ + using ThresholdTypeFlagValues = Dictionary; + + public class CoverageResultTests + { + private Modules _modules; + + public CoverageResultTests() + { + Lines lines = new Lines(); + lines.Add(1, 1); + lines.Add(2, 1); + lines.Add(3, 1); + Branches branches = new Branches(); + branches.Add(new BranchInfo { Line = 1, Hits = 1, Offset = 1, Path = 0, Ordinal = 1 }); + branches.Add(new BranchInfo { Line = 1, Hits = 1, Offset = 1, Path = 1, Ordinal = 2 }); + branches.Add(new BranchInfo { Line = 2, Hits = 0, Offset = 1, Path = 0, Ordinal = 1 }); + + Methods methods = new Methods(); + var methodString = "System.Void Coverlet.Core.Tests.CoverageResultTests::CoverageResultTests()"; + methods.Add(methodString, new Method()); + methods[methodString].Lines = lines; + methods[methodString].Branches = branches; + + + methodString = "System.Void Coverlet.Core.Tests.CoverageResultTests::GetThresholdTypesBelowThreshold()"; + methods.Add(methodString, new Method()); + methods[methodString].Lines = new Lines() + { + {1, 0}, + {2, 0}, + }; + methods[methodString].Branches = branches; + + Classes classes = new Classes(); + classes.Add("Coverlet.Core.Tests.CoverageResultTests", methods); + + Documents documents = new Documents(); + documents.Add("doc.cs", classes); + + _modules = new Modules(); + _modules.Add("module", documents); + } + + [Fact] + public void TestGetThresholdTypesBelowThresholdLine() + { + CoverageResult result = new CoverageResult(); + result.Modules = _modules; + + CoverageSummary summary = new CoverageSummary(); + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + { + { ThresholdTypeFlags.Line, 90 }, + { ThresholdTypeFlags.Method, 10 }, + { ThresholdTypeFlags.Branch, 10 }, + }; + + ThresholdTypeFlags thresholdTypeFlags = ThresholdTypeFlags.Line | ThresholdTypeFlags.Branch | ThresholdTypeFlags.Method; + ThresholdStatistic thresholdStatic = ThresholdStatistic.Minimum; + + ThresholdTypeFlags resThresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, thresholdStatic); + Assert.Equal(ThresholdTypeFlags.Line, resThresholdTypeFlags); + } + + [Fact] + public void TestGetThresholdTypesBelowThresholdMethod() + { + CoverageResult result = new CoverageResult(); + result.Modules = _modules; + + CoverageSummary summary = new CoverageSummary(); + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + { + { ThresholdTypeFlags.Line, 50 }, + { ThresholdTypeFlags.Method, 75 }, + { ThresholdTypeFlags.Branch, 10 }, + }; + + ThresholdTypeFlags thresholdTypeFlags = ThresholdTypeFlags.Line | ThresholdTypeFlags.Branch | ThresholdTypeFlags.Method; + ThresholdStatistic thresholdStatic = ThresholdStatistic.Minimum; + + ThresholdTypeFlags resThresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, thresholdStatic); + Assert.Equal(ThresholdTypeFlags.Method, resThresholdTypeFlags); + } + + [Fact] + public void TestGetThresholdTypesBelowThresholdBranch() + { + CoverageResult result = new CoverageResult(); + result.Modules = _modules; + + CoverageSummary summary = new CoverageSummary(); + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + { + { ThresholdTypeFlags.Line, 50 }, + { ThresholdTypeFlags.Method, 50 }, + { ThresholdTypeFlags.Branch, 90 }, + }; + + ThresholdTypeFlags thresholdTypeFlags = ThresholdTypeFlags.Line | ThresholdTypeFlags.Branch | ThresholdTypeFlags.Method; + ThresholdStatistic thresholdStatic = ThresholdStatistic.Total; + + ThresholdTypeFlags resThresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, thresholdStatic); + Assert.Equal(ThresholdTypeFlags.Branch, resThresholdTypeFlags); + } + + [Fact] + public void TestGetThresholdTypesBelowThresholdAllGood() + { + CoverageResult result = new CoverageResult(); + result.Modules = _modules; + + CoverageSummary summary = new CoverageSummary(); + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + { + { ThresholdTypeFlags.Line, 50 }, + { ThresholdTypeFlags.Method, 50 }, + { ThresholdTypeFlags.Branch, 50 }, + }; + + ThresholdTypeFlags thresholdTypeFlags = ThresholdTypeFlags.Line | ThresholdTypeFlags.Branch | ThresholdTypeFlags.Method; + ThresholdStatistic thresholdStatic = ThresholdStatistic.Average; + + ThresholdTypeFlags resThresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, thresholdStatic); + Assert.Equal(ThresholdTypeFlags.None, resThresholdTypeFlags); + } + + [Fact] + public void TestGetThresholdTypesBelowThresholdAllFail() + { + CoverageResult result = new CoverageResult(); + result.Modules = _modules; + + CoverageSummary summary = new CoverageSummary(); + ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + { + { ThresholdTypeFlags.Line, 100 }, + { ThresholdTypeFlags.Method, 100 }, + { ThresholdTypeFlags.Branch, 100 }, + }; + + ThresholdTypeFlags thresholdTypeFlags = ThresholdTypeFlags.Line | ThresholdTypeFlags.Branch | ThresholdTypeFlags.Method; + ThresholdStatistic thresholdStatic = ThresholdStatistic.Minimum; + + ThresholdTypeFlags resThresholdTypeFlags = result.GetThresholdTypesBelowThreshold(summary, thresholdTypeFlagValues, thresholdTypeFlags, thresholdStatic); + Assert.Equal(thresholdTypeFlags, resThresholdTypeFlags); + } + } +} \ No newline at end of file From 3d44e4631314e0179a0ad1ef8d7b03c67ae7d0d7 Mon Sep 17 00:00:00 2001 From: Arun Subramanian Date: Sun, 28 Apr 2019 14:48:13 -0700 Subject: [PATCH 2/2] Code review fixes --- src/coverlet.console/Program.cs | 10 ++++------ src/coverlet.core/CoverageResult.cs | 4 +--- src/coverlet.core/Properties/AssemblyInfo.cs | 2 +- .../CoverageResultTask.cs | 6 ++---- .../CoverageResultTests.cs | 19 ++++++++++--------- 5 files changed, 18 insertions(+), 23 deletions(-) diff --git a/src/coverlet.console/Program.cs b/src/coverlet.console/Program.cs index ddebc82ba..3cdcb7660 100644 --- a/src/coverlet.console/Program.cs +++ b/src/coverlet.console/Program.cs @@ -15,8 +15,6 @@ namespace Coverlet.Console { - using ThresholdTypeFlagValues = Dictionary; - class Program { static int Main(string[] args) @@ -157,18 +155,18 @@ static int Main(string[] args) } } - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues(); + Dictionary thresholdTypeFlagValues = new Dictionary(); if (threshold.HasValue() && threshold.Value().Contains(',')) { - var thresholdValues = threshold.Value().Split(',').Select(t => t.Trim()); + var thresholdValues = threshold.Value().Split(',', 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()}) doesnt match"); } - foreach (var _threshold in thresholdValues) + foreach (var thresholdValue in thresholdValues) { - thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = double.Parse(_threshold); + thresholdTypeFlagValues[thresholdTypeFlagQueue.Dequeue()] = double.Parse(thresholdValue); } } else diff --git a/src/coverlet.core/CoverageResult.cs b/src/coverlet.core/CoverageResult.cs index 2cb11d518..a166ee78d 100644 --- a/src/coverlet.core/CoverageResult.cs +++ b/src/coverlet.core/CoverageResult.cs @@ -8,8 +8,6 @@ namespace Coverlet.Core { - using ThresholdTypeFlagValues = Dictionary; - public class BranchInfo { public int Line { get; set; } @@ -163,7 +161,7 @@ private bool IsAsyncStateMachineMethod(string method) return false; } - public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summary, ThresholdTypeFlagValues thresholdTypeFlagValues, ThresholdTypeFlags thresholdTypes, ThresholdStatistic thresholdStat) + public ThresholdTypeFlags GetThresholdTypesBelowThreshold(CoverageSummary summary, Dictionary thresholdTypeFlagValues, ThresholdTypeFlags thresholdTypes, ThresholdStatistic thresholdStat) { var thresholdTypeFlags = ThresholdTypeFlags.None; switch (thresholdStat) diff --git a/src/coverlet.core/Properties/AssemblyInfo.cs b/src/coverlet.core/Properties/AssemblyInfo.cs index 2396fe638..cce4d926d 100644 --- a/src/coverlet.core/Properties/AssemblyInfo.cs +++ b/src/coverlet.core/Properties/AssemblyInfo.cs @@ -1,4 +1,4 @@ -[assembly: System.Reflection.AssemblyKeyFile("coverlet.core.snk")] +[assembly: System.Reflection.AssemblyKeyFileAttribute("coverlet.core.snk")] [assembly: System.Runtime.CompilerServices.InternalsVisibleTo("Coverlet.Core.Tests,PublicKey=" + "0024000004800000940000000602000000240000525341310004000001000100757cf9291d78a8" + "2e5bb58a827a3c46c2f959318327ad30d1b52e918321ffbd847fb21565b8576d2a3a24562a93e8" + diff --git a/src/coverlet.msbuild.tasks/CoverageResultTask.cs b/src/coverlet.msbuild.tasks/CoverageResultTask.cs index f3325d415..981f9fa95 100644 --- a/src/coverlet.msbuild.tasks/CoverageResultTask.cs +++ b/src/coverlet.msbuild.tasks/CoverageResultTask.cs @@ -12,8 +12,6 @@ namespace Coverlet.MSbuild.Tasks { - using ThresholdTypeFlagValues = Dictionary; - public class CoverageResultTask : Task { private string _output; @@ -131,10 +129,10 @@ public override bool Execute() } } - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues(); + Dictionary thresholdTypeFlagValues = new Dictionary(); if (_threshold.Contains(',')) { - var thresholdValues = _threshold.Split(',').Select(t => t.Trim()); + var 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()}) doesnt match"); diff --git a/test/coverlet.core.tests/CoverageResultTests.cs b/test/coverlet.core.tests/CoverageResultTests.cs index f202ed875..06809a91d 100644 --- a/test/coverlet.core.tests/CoverageResultTests.cs +++ b/test/coverlet.core.tests/CoverageResultTests.cs @@ -9,8 +9,6 @@ namespace Coverlet.Core.Tests { - using ThresholdTypeFlagValues = Dictionary; - public class CoverageResultTests { private Modules _modules; @@ -26,13 +24,14 @@ public CoverageResultTests() branches.Add(new BranchInfo { Line = 1, Hits = 1, Offset = 1, Path = 1, Ordinal = 2 }); branches.Add(new BranchInfo { Line = 2, Hits = 0, Offset = 1, Path = 0, Ordinal = 1 }); + // System.Void Coverlet.Core.Tests.CoverageResultTests::CoverageResultTests - 3/3 100% line 2/3 66.7% branch coverage Methods methods = new Methods(); var methodString = "System.Void Coverlet.Core.Tests.CoverageResultTests::CoverageResultTests()"; methods.Add(methodString, new Method()); methods[methodString].Lines = lines; methods[methodString].Branches = branches; - + // System.Void Coverlet.Core.Tests.CoverageResultTests::GetThresholdTypesBelowThreshold - 0/2 0% line methodString = "System.Void Coverlet.Core.Tests.CoverageResultTests::GetThresholdTypesBelowThreshold()"; methods.Add(methodString, new Method()); methods[methodString].Lines = new Lines() @@ -40,10 +39,12 @@ public CoverageResultTests() {1, 0}, {2, 0}, }; - methods[methodString].Branches = branches; Classes classes = new Classes(); classes.Add("Coverlet.Core.Tests.CoverageResultTests", methods); + // Methods - 1/2 (50%) + // Lines - 3/5 (60%) + // Branches - 2/3 (66.67%) Documents documents = new Documents(); documents.Add("doc.cs", classes); @@ -59,7 +60,7 @@ public void TestGetThresholdTypesBelowThresholdLine() result.Modules = _modules; CoverageSummary summary = new CoverageSummary(); - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + Dictionary thresholdTypeFlagValues = new Dictionary() { { ThresholdTypeFlags.Line, 90 }, { ThresholdTypeFlags.Method, 10 }, @@ -80,7 +81,7 @@ public void TestGetThresholdTypesBelowThresholdMethod() result.Modules = _modules; CoverageSummary summary = new CoverageSummary(); - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + Dictionary thresholdTypeFlagValues = new Dictionary() { { ThresholdTypeFlags.Line, 50 }, { ThresholdTypeFlags.Method, 75 }, @@ -101,7 +102,7 @@ public void TestGetThresholdTypesBelowThresholdBranch() result.Modules = _modules; CoverageSummary summary = new CoverageSummary(); - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + Dictionary thresholdTypeFlagValues = new Dictionary() { { ThresholdTypeFlags.Line, 50 }, { ThresholdTypeFlags.Method, 50 }, @@ -122,7 +123,7 @@ public void TestGetThresholdTypesBelowThresholdAllGood() result.Modules = _modules; CoverageSummary summary = new CoverageSummary(); - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + Dictionary thresholdTypeFlagValues = new Dictionary() { { ThresholdTypeFlags.Line, 50 }, { ThresholdTypeFlags.Method, 50 }, @@ -143,7 +144,7 @@ public void TestGetThresholdTypesBelowThresholdAllFail() result.Modules = _modules; CoverageSummary summary = new CoverageSummary(); - ThresholdTypeFlagValues thresholdTypeFlagValues = new ThresholdTypeFlagValues() + Dictionary thresholdTypeFlagValues = new Dictionary() { { ThresholdTypeFlags.Line, 100 }, { ThresholdTypeFlags.Method, 100 },