public static List <FileCoverageData> GenerateSourceFiles(XDocument document)
{
_ = document ?? throw new ArgumentNullException(nameof(document));
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, CultureInfo.InvariantCulture);
var sourceEndLine = int.Parse(range.Attribute("end_line") !.Value, CultureInfo.InvariantCulture);
var covered = range.Attribute("covered") !.Value == "yes";
var sourceLineNumbers = Enumerable.Range(
sourceStartLine,
sourceEndLine - sourceStartLine + 1);
foreach (var lineNumber in sourceLineNumbers)
{
coverageBuilder.RecordCoverage(lineNumber, covered ? 1 : 0);
}
}
}
}
}
}
files.Add(coverageBuilder.CreateFile());
}
}
}
}
return(files);
}
public static List <FileCoverageData> GenerateSourceFiles(XDocument document)
{
_ = document ?? throw new ArgumentNullException(nameof(document));
var coverage = new List <FileCoverageData>();
var xElement = document.Root;
if (xElement != null)
{
foreach (var module in xElement.Elements("module"))
{
var files = new Dictionary <string, FileCoverageDataBuilder>();
foreach (var method in module.Elements("method"))
{
XAttribute attribute = method.Attribute("excluded") !;
if (!string.IsNullOrEmpty(attribute?.Value) &&
bool.Parse(attribute.Value))
{
continue;
}
foreach (var seqpnt in method.Elements("seqpnt"))
{
attribute = method.Attribute("excluded") !;
if (!string.IsNullOrEmpty(attribute?.Value) &&
bool.Parse(attribute.Value))
{
continue;
}
var sourceLine =
int.Parse(seqpnt.Attribute("line") !.Value, CultureInfo.InvariantCulture);
var visitCount =
int.Parse(seqpnt.Attribute("visitcount") !.Value, CultureInfo.InvariantCulture);
var file = seqpnt.Attribute("doc" + "ument") !.Value; // avoid false positive error CC0021: Use 'nameof(document)'
if (!files.ContainsKey(file))
{
files[file] = new FileCoverageDataBuilder(file);
}
files[file].RecordCoverage(sourceLine, visitCount);
}
}
coverage.AddRange(files.Values.Select(builder => builder.CreateFile()));
}
}
return(coverage);
}
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 static List <FileCoverageData> GenerateSourceFiles(string[] lines)
{
_ = lines ?? throw new ArgumentNullException(nameof(lines));
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, CultureInfo.InvariantCulture);
var coverageNumber = int.Parse(matches.Groups[2].Value, CultureInfo.InvariantCulture);
coverageBuilder.RecordCoverage(lineNumber, coverageNumber);
}
continue;
}
if (line.Equals("end_of_record", StringComparison.Ordinal) && 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 static List <FileCoverageData> GenerateSourceFiles(XDocument document)
{
var files = new List <FileCoverageData>();
if (document.Root != null)
{
var sourceFilesInfo = new Dictionary <string, string>();
foreach (var sourceFile in document.Root.Elements("SourceFileNames"))
{
var idElement = sourceFile.Element("SourceFileID");
if (idElement == null)
{
continue;
}
var id = idElement.Value;
var fileNameElement = sourceFile.Element("SourceFileName");
if (fileNameElement == null)
{
continue;
}
var fileName = fileNameElement.Value;
sourceFilesInfo.Add(id, fileName);
}
foreach (var module in document.Root.Elements("Module"))
{
foreach (var sourceFileInfo in sourceFilesInfo)
{
var fileId = sourceFileInfo.Key;
var fullPath = sourceFileInfo.Value;
var coverageBuilder = new FileCoverageDataBuilder(fullPath);
var namespaceTable = module.Element("NamespaceTable");
if (namespaceTable == null)
{
continue;
}
foreach (var @class in namespaceTable.Elements("Class"))
{
foreach (var method in @class.Elements("Method"))
{
foreach (var lines in method.Elements("Lines"))
{
var sourceFileIdElement = lines.Element("SourceFileID");
if (sourceFileIdElement == null)
{
continue;
}
var sourceFileId = sourceFileIdElement.Value;
if (sourceFileId != fileId)
{
continue;
}
var sourceStartLineElement = lines.Element("LnStart");
if (sourceStartLineElement == null)
{
continue;
}
var sourceStartLine = int.Parse(sourceStartLineElement.Value, CultureInfo.InvariantCulture);
var sourceEndLineElement = lines.Element("LnEnd");
if (sourceEndLineElement == null)
{
continue;
}
var sourceEndLine = int.Parse(sourceEndLineElement.Value, CultureInfo.InvariantCulture);
var coveredElement = lines.Element("Coverage");
if (coveredElement == null)
{
continue;
}
// 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);
}
}
}
}
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);
}
}
public static List <FileCoverageData> GenerateSourceFiles(XDocument document)
{
_ = document ?? throw new ArgumentNullException(nameof(document));
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, CultureInfo.InvariantCulture);
var visitCount =
int.Parse(sequencePoint.Attribute("vc") !.Value, CultureInfo.InvariantCulture);
coverageBuilder.RecordCoverage(sourceLine, visitCount);
}
}
}
}
}
}
}
files.Add(coverageBuilder.CreateFile());
}
}
}
}
}
return(files);
}