public static int IsHigherThanThreshold(InstrumentationResult result, float threshold)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
var files = result.GetSourceFiles();
var totalLines = 0;
var totalCoveredLines = 0;
foreach (var kvFile in files)
{
var lines = kvFile.Value.Sequences
.SelectMany(i => i.GetLines())
.Distinct()
.Count();
var coveredLines = kvFile.Value.Sequences
.Where(h => hits.WasHit(h.HitId))
.SelectMany(i => i.GetLines())
.Distinct()
.Count();
totalLines += lines;
totalCoveredLines += coveredLines;
}
var totalCoveragePercentage = (float)totalCoveredLines / totalLines;
var isHigherThanThreshold = totalCoveragePercentage >= threshold;
return(isHigherThanThreshold ? 0 : 1);
}
public static Summary CalculateSummaryStatic(
InstrumentationResult result,
float threshold)
{
var hitsInfo = HitsInfo.TryReadFromDirectory(result.HitsPath);
return(CalculateFilesSummary(
result.GetSourceFiles(),
hitsInfo,
threshold));
}
public virtual int Execute(InstrumentationResult result, float threshold)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
var files = result.GetSourceFiles();
SetFileColumnLength(files.Keys.Select(s => s.Length).Concat(new[] { 10 }).Max());
WriteHeader();
var totalLines = 0;
var totalCoveredLines = 0;
foreach (var kvFile in files)
{
var lines = kvFile.Value.Sequences
.SelectMany(i => i.GetLines())
.Distinct()
.Count();
var coveredLines = kvFile.Value.Sequences
.Where(h => hits.WasHit(h.HitId))
.SelectMany(i => i.GetLines())
.Distinct()
.Count();
totalLines += lines;
totalCoveredLines += coveredLines;
var coveragePercentage = (float)coveredLines / lines;
var fileColor = coveragePercentage >= threshold ? ConsoleColor.Green : ConsoleColor.Red;
WriteReport(kvFile, lines, coveredLines, coveragePercentage, fileColor);
}
WriteDetailedReport(result, files, hits);
var totalCoveragePercentage = (float)totalCoveredLines / totalLines;
var isHigherThanThreshold = totalCoveragePercentage >= threshold;
var totalsColor = isHigherThanThreshold ? ConsoleColor.Green : ConsoleColor.Red;
WriteFooter(totalLines, totalCoveredLines, totalCoveragePercentage, threshold, totalsColor);
return(isHigherThanThreshold ? 0 : 1);
}
public void Execute(InstrumentationResult result, IFileInfo output)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
var document = new XDocument(
new XDeclaration("1.0", "utf-8", null),
CreateCoverageElement(result, hits)
);
var xmlWriterSettings = new XmlWriterSettings
{
Indent = true
};
output.Directory.Create();
using (var sw = output.CreateText())
using (var writer = XmlWriter.Create(sw, xmlWriterSettings))
{
document.WriteTo(writer);
}
}
public int Execute(
InstrumentationResult result,
float threshold,
bool noFail)
{
var hitsInfo = HitsInfo.TryReadFromDirectory(result.HitsPath);
var files = result.GetSourceFiles();
var summary = SummaryFactory.CalculateFilesSummary(files, hitsInfo, threshold);
var tableRows = SummaryFactory.GetSummaryGrid(files, hitsInfo, threshold);
var consoleTable = new ConsoleTable
{
Header = CreateHeader(),
Body = tableRows.Where(r => !r.Root).Select(f => CreateRow(f)).ToArray(),
Footer = CreateFooter(summary)
};
consoleTable.WriteTable();
return(noFail || summary.LinesCoveragePass ? 0 : 1);
}
public void Execute(InstrumentationResult result, IFileInfo output)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
int fileIndex = 0;
int sequencePointMegaCounter = 0;
var data = new XProcessingInstruction("xml-stylesheet", "type='text/xsl' href='coverage.xsl'");
var document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"), data);
var coverageElement = new XElement(
XName.Get("CoverageSession")
);
var modulesListElement = new XElement("Modules", result.Assemblies.Select(assembly =>
{
var moduleElement = new XElement(
XName.Get("Module"),
new XAttribute(XName.Get("hash"), Guid.NewGuid().ToString())
);
var fullNameElement = new XElement(
XName.Get("FullName"),
new XText(assembly.Name)
);
var moduleNameElement = new XElement(
XName.Get("ModuleName"),
new XText(assembly.Name)
);
Dictionary <SourceFile, int> dctSourceFileCount = new Dictionary <SourceFile, int>();
var filesElement = new XElement("Files", assembly.SourceFiles.Select(file =>
{
dctSourceFileCount.Add(file, ++fileIndex);
var fileElement = new XElement(
XName.Get("File"),
new XAttribute(XName.Get("uid"), dctSourceFileCount[file]),
new XAttribute(XName.Get("fullPath"), Path.Combine(result.SourcePath, file.Path))
);
return(fileElement);
}));
var classesElement = new XElement("Classes", assembly.SourceFiles.Select(file =>
{
var hitInstructions = file.Sequences.Where(h => hits.WasHit(h.HitId)).ToArray();
return(file.Sequences
.GroupBy(instruction => new { instruction.Method.Class })
.Select(classes =>
{
var classElement = new XElement(
XName.Get("Class")
);
var classfullNameElement = new XElement(
XName.Get("FullName"),
new XText(classes.Key.Class)
);
var methodsList = new XElement("Methods", classes
.GroupBy(instruction => instruction.Method)
.Select(method =>
{
var nameElement = new XElement(
XName.Get("Name"),
new XText(method.Key.FullName)
);
var fileRefElement = new XElement(
XName.Get("FileRef"),
new XAttribute(XName.Get("uid"), dctSourceFileCount[file])
);
int sequencePointMiniCounter = 0;
var sequencePoints = new XElement("SequencePoints", method
.OrderBy(methodPoint => methodPoint.StartLine)
.Select(methodPoint =>
{
var hitCount = hitInstructions.Count(hit => hit.Equals(methodPoint));
return new XElement(
XName.Get("SequencePoint"),
new XAttribute(XName.Get("vc"), hitCount),
new XAttribute(XName.Get("uspid"), ++sequencePointMegaCounter),
new XAttribute(XName.Get("ordinal"), ++sequencePointMiniCounter),
new XAttribute(XName.Get("sl"), methodPoint.StartLine),
new XAttribute(XName.Get("sc"), methodPoint.StartColumn),
new XAttribute(XName.Get("el"), methodPoint.EndLine),
new XAttribute(XName.Get("ec"), methodPoint.EndColumn)
);
}));
var methodElement = new XElement(
XName.Get("Method"),
new XAttribute(XName.Get("visited"), method.Any(p => hitInstructions.Any(hit => hit == p))),
new XAttribute(XName.Get("isConstructor"), method.Key.Name == ".ctor")
);
methodElement.Add(nameElement);
methodElement.Add(fileRefElement);
methodElement.Add(sequencePoints);
return methodElement;
}));
classElement.Add(classfullNameElement);
classElement.Add(methodsList);
return classElement;
}));
}));
moduleElement.Add(fullNameElement);
moduleElement.Add(moduleNameElement);
moduleElement.Add(filesElement);
moduleElement.Add(classesElement);
return(moduleElement);
}));
coverageElement.Add(modulesListElement);
document.Add(coverageElement);
output.Directory.Create();
File.WriteAllText(output.FullName, document.ToString());
}
public virtual async Task <int> Execute(InstrumentationResult result)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
var files = result.GetSourceFiles();
var coverallsJob = new CoverallsJobModel
{
ServiceJobId = _serviceJobId,
ServiceName = _serviceName,
RepoToken = _repoToken,
CoverallsGitModel = !string.IsNullOrWhiteSpace(_branch)
? new CoverallsGitModel
{
Head = !string.IsNullOrWhiteSpace(_commit)
? new CoverallsCommitModel
{
Id = _commit,
AuthorName = _commitAuthorName,
AuthorEmail = _commitAuthorEmail,
CommitterName = _commitCommitterName,
CommitterEmail = _commitCommitterEmail,
Message = _commitMessage
}
: null,
Branch = _branch,
Remotes = !string.IsNullOrWhiteSpace(_remoteUrl)
? new List <CoverallsRemote>
{
new CoverallsRemote
{
Name = _remoteName,
Url = _remoteUrl
}
}
: null
}
: null,
SourceFiles = new List <CoverallsSourceFileModel>()
};
foreach (var kvFile in files)
{
var sourceFile = Path.Combine(result.SourcePath, kvFile.Key);
if (!File.Exists(sourceFile))
{
Console.WriteLine($"File not found: {sourceFile}");
continue;
}
var sourceLines = File.ReadAllLines(sourceFile);
var hitsPerLine = kvFile.Value.Instructions
.SelectMany(i => i.GetLines(), (instruction, line) => new { instruction, line })
.GroupBy(i => i.line)
.ToDictionary(g => g.Key, g => g.Sum(j => hits.GetInstructionHitCount(j.instruction.Id)));
var fileName = Path.GetRelativePath(_rootFolder, sourceFile).Replace("\\", "/");
var coverallsSourceFileModel = new CoverallsSourceFileModel
{
Name = fileName,
SourceDigest = ComputeSourceDigest(sourceFile),
Coverage = Enumerable.Range(1, sourceLines.Length).Select(line =>
{
return(hitsPerLine.ContainsKey(line)
? hitsPerLine[line]
: default(int?));
}).ToArray()
};
coverallsJob.SourceFiles.Add(coverallsSourceFileModel);
}
var coverallsJson = JsonConvert.SerializeObject(coverallsJob, Formatting.None, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
if (!string.IsNullOrWhiteSpace(_output))
{
File.WriteAllText(_output, coverallsJson);
}
return(await Post(coverallsJson));
}
public static void Execute(InstrumentationResult result, FileInfo output, float threshold)
{
var hits = HitsInfo.TryReadFromDirectory(result.HitsPath);
var data = new XProcessingInstruction("xml-stylesheet", "type='text/xsl' href='coverage.xsl'");
var document = new XDocument(new XDeclaration("1.0", "utf-8", "yes"), data);
var coverageElement = new XElement(
XName.Get("coverage"),
new XAttribute(XName.Get("profilerVersion"), 0),
new XAttribute(XName.Get("driverVersion"), 0),
new XAttribute(XName.Get("startTime"), DateTime.MaxValue.ToString("o")),
new XAttribute(XName.Get("measureTime"), DateTime.MinValue.ToString("o"))
);
var modules = result.Assemblies.Select(assembly =>
{
var module = new XElement(
XName.Get("module"),
new XAttribute(XName.Get("moduleId"), Guid.NewGuid().ToString()),
new XAttribute(XName.Get("name"), assembly.Name),
new XAttribute(XName.Get("assembly"), assembly.Name),
new XAttribute(XName.Get("assemblyIdentity"), assembly.Name)
);
var methods = assembly.SourceFiles.Select(file =>
{
return(file.Value.Sequences
.GroupBy(instruction => instruction.Method)
.Select(instruction =>
{
var method = new XElement(
XName.Get("method"),
new XAttribute(XName.Get("name"), instruction.Key.Name),
new XAttribute(XName.Get("class"), instruction.Key.Class),
new XAttribute(XName.Get("excluded"), "false"),
new XAttribute(XName.Get("instrumented"), "true"),
new XAttribute(XName.Get("fullname"), instruction.Key.FullName)
);
var methodPoints = instruction.Select(methodPoint =>
{
var counter = hits.GetHitCount(methodPoint.HitId);
var point = new XElement(
XName.Get("seqpnt"),
new XAttribute(XName.Get("visitcount"), counter),
new XAttribute(XName.Get("line"), methodPoint.StartLine),
new XAttribute(XName.Get("column"), methodPoint.StartColumn),
new XAttribute(XName.Get("endline"), methodPoint.EndLine),
new XAttribute(XName.Get("endcolumn"), methodPoint.EndColumn),
new XAttribute(XName.Get("excluded"), "false"),
new XAttribute(XName.Get("document"), Path.Combine(result.SourcePath, file.Key))
);
return point;
});
method.Add(methodPoints);
return method;
}));
});
module.Add(methods);
return(module);
});
coverageElement.Add(modules);
document.Add(coverageElement);
output.Directory.Create();
File.WriteAllText(output.FullName, document.ToString());
}
public virtual int Execute(InstrumentationResult result, IDirectoryInfo output, float threshold, bool noFail)
{
Directory.CreateDirectory(output.FullName);
var hitsInfo = HitsInfo.TryReadFromDirectory(result.HitsPath);
var fileName = Path.Combine(output.FullName, "index.html");
var sourceFiles = result.GetSourceFiles();
var totalLines = sourceFiles.Sum(sf =>
sf.Sequences
.SelectMany(s => s.GetLines())
.Distinct()
.Count()
);
var totalCoveredLines = sourceFiles.Sum(sf =>
sf.Sequences
.Where(s => hitsInfo.WasHit(s.HitId))
.SelectMany(s => s.GetLines())
.Distinct()
.Count()
);
var totalCoveragePercentage = (float)totalCoveredLines / totalLines;
var isHigherThanThreshold = totalCoveragePercentage >= threshold;
var totalThresholdClass = isHigherThanThreshold ? "green" : "red";
using (var htmlWriter = (TextWriter)File.CreateText(fileName))
{
htmlWriter.WriteLine("<html>");
htmlWriter.WriteLine("<style>");
htmlWriter.WriteLine(ResourceUtils.GetContent("MiniCover.Reports.Html.Shared.css"));
htmlWriter.WriteLine(ResourceUtils.GetContent("MiniCover.Reports.Html.Summary.css"));
htmlWriter.WriteLine("</style>");
htmlWriter.WriteLine("<script>");
htmlWriter.WriteLine(ResourceUtils.GetContent("MiniCover.Reports.Html.Shared.js"));
htmlWriter.WriteLine("</script>");
htmlWriter.WriteLine("<body>");
// Write summary
htmlWriter.WriteLine("<h2>Summary</h2>");
htmlWriter.WriteLine("<table>");
htmlWriter.WriteLine($"<tr><th>Generated on</th><td>{DateTime.Now}</td></tr>");
htmlWriter.WriteLine($"<tr><th>Threshold</th><td>{threshold:P}</td></tr>");
htmlWriter.WriteLine("</table>");
// Write detailed report
htmlWriter.WriteLine("<h2>Source Files</h2>");
htmlWriter.WriteLine("<table border=\"1\" cellpadding=\"5\">");
htmlWriter.WriteLine("<tr>");
htmlWriter.WriteLine("<th>File</th>");
htmlWriter.WriteLine("<th class=\"value\">Lines</th>");
htmlWriter.WriteLine("<th class=\"value\">% Lines</th>");
htmlWriter.WriteLine("<th class=\"value\">Stmts</th>");
htmlWriter.WriteLine("<th class=\"value\">% Stmts</th>");
htmlWriter.WriteLine("<th class=\"value\">Branches</th>");
htmlWriter.WriteLine("<th class=\"value\">% Branches</th>");
htmlWriter.WriteLine("</tr>");
foreach (var summaryRow in SummaryFactory.GetSummaryGrid(result.GetSourceFiles(), hitsInfo, threshold))
{
var summary = summaryRow.Summary;
var statementsCoverageClass = summary.StatementsCoveragePass ? "green" : "red";
var linesCoverageClass = summary.LinesCoveragePass ? "green" : "red";
var branchesCoverageClass = summary.BranchesCoveragePass ? "green" : "red";
var classes = new List <string> {
};
if (summaryRow.Level == 0)
{
classes.Add("root");
}
if (summaryRow.Folder)
{
classes.Add("folder");
}
if (summaryRow.File)
{
classes.Add("file");
}
var marginLeft = Math.Max(summaryRow.Level - 1, 0) * 20;
htmlWriter.WriteLine($"<tr class=\"{string.Join(" ", classes)}\">");
htmlWriter.WriteLine($"<td>");
if (summaryRow.SourceFiles.Length == 1)
{
var indexRelativeFileName = GetIndexRelativeHtmlFileName(summaryRow.SourceFiles[0].Path);
htmlWriter.WriteLine($"<a class=\"name\" href=\"{indexRelativeFileName}\" style=\"margin-left: {marginLeft}px\">{summaryRow.Name}</a>");
}
else
{
htmlWriter.WriteLine($"<span class=\"name\" style=\"margin-left: {marginLeft}px\">{summaryRow.Name}</span");
}
htmlWriter.WriteLine("</td>");
htmlWriter.WriteLine($"<td class=\"value {linesCoverageClass}\">{summary.CoveredLines} / {summary.Lines}</td>");
htmlWriter.WriteLine($"<td class=\"value {linesCoverageClass}\">{summary.LinesPercentage:P}</td>");
htmlWriter.WriteLine($"<td class=\"value {statementsCoverageClass}\">{summary.CoveredStatements} / {summary.Statements}</td>");
htmlWriter.WriteLine($"<td class=\"value {statementsCoverageClass}\">{summary.StatementsPercentage:P}</td>");
htmlWriter.WriteLine($"<td class=\"value {branchesCoverageClass}\">{summary.CoveredBranches} / {summary.Branches}</td>");
htmlWriter.WriteLine($"<td class=\"value {branchesCoverageClass}\">{summary.BranchesPercentage:P}</td>");
htmlWriter.WriteLine("</tr>");
if (summaryRow.SourceFiles.Length == 1)
{
var relativeFileName = GetHtmlFileName(output, summaryRow.SourceFiles[0].Path);
new HtmlSourceFileReport()
.Generate(result, summaryRow.SourceFiles.First(), hitsInfo, threshold, relativeFileName);
}
}
htmlWriter.WriteLine("</table>");
htmlWriter.WriteLine("</body>");
htmlWriter.WriteLine("</html>");
}
return(noFail || isHigherThanThreshold ? 0 : 1);
}