< Summary

Information
Class: DirectSight.Parser.Analysis.SummaryResult
Assembly DirectSight
File(s): /home/runner/work/DirectSight/DirectSight/DirectSight/Parser/Analysis/SummaryResult.cs
Line coverage
73%
Covered lines: 48
Uncovered lines: 17
Coverable lines: 65
Total lines: 204
Line coverage: 73.8%
Branch coverage
55%
Covered branches: 19
Total branches: 34
Branch coverage: 55.8%
Method coverage

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
.ctor(...)50%44100%
CoverageDate()0%880%

File(s)

/home/runner/work/DirectSight/DirectSight/DirectSight/Parser/Analysis/SummaryResult.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using System.Linq;
 4using DirectSight.Common;
 5
 6namespace DirectSight.Parser.Analysis;
 7
 8/// <summary>
 9/// Overall result of all assemblies.
 10/// </summary>
 11public class SummaryResult
 12{
 13    /// <summary>
 14    /// Initializes a new instance of the <see cref="SummaryResult" /> class.
 15    /// </summary>
 16    /// <param name="parserResult">The parser result.</param>
 17    public SummaryResult(ParserResult parserResult)
 218        : this(parserResult.Assemblies, parserResult.ParserName, parserResult.SupportsBranchCoverage)
 219    {
 220        this.MinimumTimeStamp = parserResult.MinimumTimeStamp;
 221        this.MaximumTimeStamp = parserResult.MaximumTimeStamp;
 222    }
 23
 24    /// <summary>
 25    /// Initializes a new instance of the <see cref="SummaryResult" /> class.
 26    /// </summary>
 27    /// <param name="assemblies">The assemblies.</param>
 28    /// <param name="usedParser">The used parser.</param>
 29    /// <param name="supportsBranchCoverage">if set to <c>true</c> the used parser supports branch coverage.</param>
 230    public SummaryResult(
 231        IReadOnlyCollection<Assembly> assemblies,
 232        string usedParser, bool supportsBranchCoverage)
 233    {
 234        this.Assemblies = assemblies ?? throw new ArgumentNullException(nameof(assemblies));
 235        this.UsedParser = usedParser ?? throw new ArgumentNullException(nameof(usedParser));
 236        this.SupportsBranchCoverage = supportsBranchCoverage;
 237    }
 38
 39    /// <summary>
 40    /// Gets the assemblies.
 41    /// </summary>
 42    /// <value>
 43    /// The assemblies.
 44    /// </value>
 17445    public IReadOnlyCollection<Assembly> Assemblies { get; }
 46
 47    /// <summary>
 48    /// Gets the used parser.
 49    /// </summary>
 50    /// <value>
 51    /// The used parser.
 52    /// </value>
 453    public string UsedParser { get; }
 54
 55    /// <summary>
 56    /// Gets a value indicating whether the used parser supports branch coverage.
 57    /// </summary>
 58    /// <value>
 59    /// <c>true</c> if used parser supports branch coverage; otherwise, <c>false</c>.
 60    /// </value>
 4261    public bool SupportsBranchCoverage { get; }
 62
 63    /// <summary>
 64    /// Gets the timestamp on which the coverage report was generated.
 65    /// </summary>
 266    public DateTime? MinimumTimeStamp { get; }
 67
 68    /// <summary>
 69    /// Gets the timestamp on which the coverage report was generated.
 70    /// </summary>
 271    public DateTime? MaximumTimeStamp { get; }
 72
 73    /// <summary>
 74    /// Gets the number of covered lines.
 75    /// </summary>
 76    /// <value>The covered lines.</value>
 5277    public int CoveredLines => this.Assemblies.SafeSum(a => a.CoveredLines);
 78
 79    /// <summary>
 80    /// Gets the number of coverable lines.
 81    /// </summary>
 82    /// <value>The coverable lines.</value>
 8483    public int CoverableLines => this.Assemblies.SafeSum(a => a.CoverableLines);
 84
 85    /// <summary>
 86    /// Gets the number of total lines.
 87    /// </summary>
 88    /// <value>The total lines.</value>
 89    public int? TotalLines
 90    {
 91        get
 492        {
 493            var processedFiles = new HashSet<string>();
 494            int? result = null;
 95
 2096            foreach (var assembly in this.Assemblies)
 497            {
 15698                foreach (var clazz in assembly.Classes)
 7299                {
 360100                    foreach (var file in clazz.Files)
 72101                    {
 72102                        if (!processedFiles.Contains(file.Path) && file.TotalLines.HasValue)
 60103                        {
 60104                            processedFiles.Add(file.Path);
 60105                            result = result.HasValue ? result + file.TotalLines : file.TotalLines;
 60106                        }
 72107                    }
 72108                }
 4109            }
 110
 4111            return result;
 4112        }
 113    }
 114
 115    /// <summary>
 116    /// Gets the coverage quota.
 117    /// </summary>
 118    /// <value>The coverage quota.</value>
 16119    public decimal? CoverageQuota => (this.CoverableLines == 0) ? (decimal?)null : MathExtensions.CalculatePercentage(th
 120
 121    /// <summary>
 122    /// Gets the number of covered branches.
 123    /// </summary>
 124    /// <value>
 125    /// The number of covered branches.
 126    /// </value>
 52127    public int? CoveredBranches => this.Assemblies.SafeSum(f => f.CoveredBranches);
 128
 129    /// <summary>
 130    /// Gets the number of total branches.
 131    /// </summary>
 132    /// <value>
 133    /// The number of total branches.
 134    /// </value>
 84135    public int? TotalBranches => this.Assemblies.SafeSum(f => f.TotalBranches);
 136
 137    /// <summary>
 138    /// Gets the branch coverage quota.
 139    /// </summary>
 140    /// <value>The branch coverage quota.</value>
 16141    public decimal? BranchCoverageQuota => (this.TotalBranches == 0) ? (decimal?)null : MathExtensions.CalculatePercenta
 142
 143    /// <summary>
 144    /// Gets the number of covered code elements.
 145    /// </summary>
 146    /// <value>
 147    /// The number of covered code elements.
 148    /// </value>
 12149    public int CoveredCodeElements => this.Assemblies.SafeSum(f => f.CoveredCodeElements);
 150
 151    /// <summary>
 152    /// Gets the number of fully covered code elements.
 153    /// </summary>
 154    /// <value>
 155    /// The number of fully covered code elements.
 156    /// </value>
 12157    public int FullCoveredCodeElements => this.Assemblies.SafeSum(f => f.FullCoveredCodeElements);
 158
 159    /// <summary>
 160    /// Gets the number of total code elements.
 161    /// </summary>
 162    /// <value>
 163    /// The number of total code elements.
 164    /// </value>
 36165    public int TotalCodeElements => this.Assemblies.SafeSum(f => f.TotalCodeElements);
 166
 167    /// <summary>
 168    /// Gets the code elements coverage quota.
 169    /// </summary>
 170    /// <value>The code elements coverage quota.</value>
 4171    public decimal? CodeElementCoverageQuota => (this.TotalCodeElements == 0) ? (decimal?)null : MathExtensions.Calculat
 172
 173    /// <summary>
 174    /// Gets the full code elements coverage quota.
 175    /// </summary>
 176    /// <value>The full code elements coverage quota.</value>
 4177    public decimal? FullCodeElementCoverageQuota => (this.TotalCodeElements == 0) ? (decimal?)null : MathExtensions.Calc
 178
 179    /// <summary>
 180    /// Get the coverage date(s) based on the minimum and maximum timestamp.
 181    /// </summary>
 182    /// <returns> The coverage date(s).</returns>
 183    public string CoverageDate()
 0184    {
 0185        string value = null;
 186
 0187        if (this.MinimumTimeStamp.HasValue)
 0188        {
 0189            value = $"{this.MinimumTimeStamp.Value.ToShortDateString()} - {this.MinimumTimeStamp.Value.ToLongTimeString(
 190
 0191            if (this.MaximumTimeStamp.HasValue
 0192                && !this.MinimumTimeStamp.Value.Equals(this.MaximumTimeStamp.Value))
 0193            {
 0194                value += $" - {this.MaximumTimeStamp.Value.ToShortDateString()} - {this.MaximumTimeStamp.Value.ToLongTim
 0195            }
 0196        }
 0197        else if (this.MaximumTimeStamp.HasValue)
 0198        {
 0199            value = $"{this.MaximumTimeStamp.Value.ToShortDateString()} - {this.MaximumTimeStamp.Value.ToLongTimeString(
 0200        }
 201
 0202        return value;
 0203    }
 204}
Generated by DirectSight 0.1.0
2026-05-19 17:30:33 UTC+00:00
GitHub

Methods/Properties

.ctor(DirectSight.Parser.ParserResult)
.ctor(System.Collections.Generic.IReadOnlyCollection`1<DirectSight.Parser.Analysis.Assembly>,System.String,System.Boolean)
Assemblies()
UsedParser()
SupportsBranchCoverage()
MinimumTimeStamp()
MaximumTimeStamp()
CoveredLines()
CoverableLines()
TotalLines()
CoverageQuota()
CoveredBranches()
TotalBranches()
BranchCoverageQuota()
CoveredCodeElements()
FullCoveredCodeElements()
TotalCodeElements()
CodeElementCoverageQuota()
FullCodeElementCoverageQuota()
CoverageDate()