public async Task <IEnumerable <CoverageFile> > ParseSourceFiles()
{
return(await coverageFileBuilder.Build(await options.Lcov.SelectMany(ParseFile)));
async Task <IEnumerable <FileCoverageData> > ParseFile(string fileName)
{
var fileInfo = fileProvider.GetFileInfo(fileName);
if (!fileInfo.Exists)
{
throw new PublishCoverallsException($"{fileName} was not found when parsing lcov report");
}
var lines = await fileInfo.ReadAllLines();
{
FileCoverageDataBuilder coverageBuilder = null;
var files = new List <FileCoverageData>();
foreach (var line in lines)
{
var matches = Regex.Match(line, "^SF:(.*)");
if (matches.Success)
{
coverageBuilder = new FileCoverageDataBuilder(matches.Groups[1].Value);
continue;
}
matches = Regex.Match(line, @"^DA:(\d+),(\d+)");
if (matches.Success)
{
if (coverageBuilder != null)
{
var lineNumber = int.Parse(matches.Groups[1].Value);
var coverageNumber = int.Parse(matches.Groups[2].Value);
coverageBuilder.RecordCoverage(lineNumber, coverageNumber);
}
continue;
}
if (line.Equals("end_of_record"))
{
if (coverageBuilder != null)
{
files.Add(coverageBuilder.CreateFile());
coverageBuilder = null;
}
}
}
return(files);
}
}
}
public async Task <IEnumerable <CoverageFile> > ParseSourceFiles()
{
return(await coverageFileBuilder.Build(await options.VsCoverage.SelectMany(ParseFile)));
async Task <IEnumerable <FileCoverageData> > ParseFile(string fileName)
{
var fileInfo = fileProvider.GetFileInfo(fileName);
if (!fileInfo.Exists)
{
throw new PublishCoverallsException($"{fileName} was not found when parsing visual studio coverage");
}
var document = await fileInfo.ReadXml();
if (document.Root == null)
{
return(Enumerable.Empty <FileCoverageData>());
}
var builderBySourceId = new Dictionary <string, FileCoverageDataBuilder>();
var builders = new List <FileCoverageDataBuilder>();
foreach (var sourceFile in document.Root.Elements("SourceFileNames"))
{
var idElement = sourceFile.Element("SourceFileID");
var fileNameElement = sourceFile.Element("SourceFileName");
if (idElement != null && fileNameElement != null)
{
var builder = new FileCoverageDataBuilder(fileNameElement.Value);
builderBySourceId.Add(idElement.Value, builder);
builders.Add(builder);
}
}
foreach (var module in document.Root.Elements("Module"))
{
var namespaceTable = module.Element("NamespaceTable");
if (namespaceTable == null)
{
continue;
}
foreach (var lines in namespaceTable.Elements("Class")
.Elements("Method")
.Elements("Lines"))
{
var sourceFileIdElement = lines.Element("SourceFileID");
var sourceStartLineElement = lines.Element("LnStart");
var sourceEndLineElement = lines.Element("LnEnd");
var coveredElement = lines.Element("Coverage");
if (sourceFileIdElement == null ||
sourceStartLineElement == null ||
sourceEndLineElement == null ||
coveredElement == null ||
!builderBySourceId.TryGetValue(sourceFileIdElement.Value, out var coverageBuilder))
{
continue;
}
var sourceStartLine = int.Parse(sourceStartLineElement.Value);
var sourceEndLine = int.Parse(sourceEndLineElement.Value);
// A value of 2 means completely covered
var covered = coveredElement.Value == "2";
for (var lineNumber = sourceStartLine; lineNumber <= sourceEndLine; lineNumber++)
{
coverageBuilder.RecordCoverage(lineNumber, covered ? 1 : 0);
}
}
}
return(builders.Select(b => b.CreateFile()));
}
}
public async Task <IEnumerable <CoverageFile> > ParseSourceFiles()
{
return(await coverageFileBuilder.Build(await options.OpenCover.SelectMany(ParseFile)));
async Task <IEnumerable <FileCoverageData> > ParseFile(string fileName)
{
var fileInfo = fileProvider.GetFileInfo(fileName);
if (!fileInfo.Exists)
{
throw new PublishCoverallsException($"{fileName} was not found when parsing open cover report");
}
var document = await fileInfo.ReadXml();
if (document.Root == null)
{
return(Enumerable.Empty <FileCoverageData>());
}
var files = new List <FileCoverageData>();
var xElement = document.Root?.Element("Modules");
if (xElement != null)
{
foreach (var module in xElement.Elements("Module"))
{
var attribute = module.Attribute("skippedDueTo");
if (string.IsNullOrEmpty(attribute?.Value))
{
var filesElement = module.Element("Files");
if (filesElement != null)
{
foreach (var file in filesElement.Elements("File"))
{
var fileid = file.Attribute("uid")?.Value;
var fullPath = file.Attribute("fullPath")?.Value;
var coverageBuilder = new FileCoverageDataBuilder(fullPath);
var classesElement = module.Element("Classes");
if (classesElement != null)
{
foreach (var @class in classesElement.Elements("Class"))
{
var methods = @class.Element("Methods");
if (methods != null)
{
foreach (var method in methods.Elements("Method"))
{
var sequencePointsElement = method.Element("SequencePoints");
if (sequencePointsElement != null)
{
foreach (
var sequencePoint in
sequencePointsElement.Elements("SequencePoint"))
{
var sequenceFileid = sequencePoint.Attribute("fileid").Value;
if (fileid == sequenceFileid)
{
var sourceLine =
int.Parse(sequencePoint.Attribute("sl").Value);
var visitCount =
int.Parse(sequencePoint.Attribute("vc").Value);
coverageBuilder.RecordCoverage(sourceLine, visitCount);
}
}
}
}
}
}
}
files.Add(coverageBuilder.CreateFile());
}
}
}
}
}
return(files);
}
}
public async Task <IEnumerable <CoverageFile> > ParseSourceFiles()
{
return(await coverageFileBuilder.Build(await options.DynamicCodeCoverage.SelectMany(ParseFile)));
async Task <IEnumerable <FileCoverageData> > ParseFile(string fileName)
{
var fileInfo = fileProvider.GetFileInfo(fileName);
if (!fileInfo.Exists)
{
throw new PublishCoverallsException($"{fileName} was not found when parsing dynamic coverage");
}
var document = await fileInfo.ReadXml();
var files = new List <FileCoverageData>();
var xElement = document.Root?.Element("modules");
if (xElement != null)
{
foreach (var module in xElement.Elements("module"))
{
var filesElement = module.Element("source_files");
if (filesElement != null)
{
foreach (var file in filesElement.Elements("source_file"))
{
var fileid = file.Attribute("id").Value;
var fullPath = file.Attribute("path").Value;
var coverageBuilder = new FileCoverageDataBuilder(fullPath);
var classesElement = module.Element("functions");
if (classesElement != null)
{
foreach (var @class in classesElement.Elements("function"))
{
var ranges = @class.Element("ranges");
if (ranges != null)
{
foreach (var range in ranges.Elements("range"))
{
var rangeFileId = range.Attribute("source_id").Value;
if (fileid == rangeFileId)
{
var sourceStartLine = int.Parse(range.Attribute("start_line").Value);
var sourceEndLine = int.Parse(range.Attribute("end_line").Value);
var covered = range.Attribute("covered").Value == "yes";
foreach (
var lineNumber in
Enumerable.Range(sourceStartLine,
sourceEndLine - sourceStartLine + 1))
{
coverageBuilder.RecordCoverage(lineNumber, covered ? 1 : 0);
}
}
}
}
}
}
files.Add(coverageBuilder.CreateFile());
}
}
}
}
return(files);
}
}