public void ShouldNotProcessWhenNoFiles()
{
var filesTest = new List <string>();
var summaryResult = new SummaryResult
{
AmoutClients = 1,
AmoutSalesman = 1,
FileName = "Test.dat",
IdExpensiveSale = "1a",
WorstSalesman = "fulano"
};
_fileManagementMock.Setup(x => x.Scanner()).Returns(filesTest);
_fileProcessorMock.Setup(x => x.SummarizeFile(It.IsAny <string>())).Returns(summaryResult);
_fileManagementMock.Setup(x => x.SaveFile(summaryResult));
_fileManagementMock.Setup(x => x.MoveForProcessing(It.IsAny <string>()));
_fileProcessingService.ProcessFiles();
_fileManagementMock.Verify(x => x.Scanner(), Times.Once);
_fileProcessorMock.Verify(x => x.SummarizeFile(It.IsAny <string>()), Times.Never);
_fileManagementMock.Verify(x => x.SaveFile(summaryResult), Times.Never);
_fileManagementMock.Verify(x => x.MoveForProcessing(It.IsAny <string>()), Times.Never);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(true))
{
this.CreateSummaryReport(renderer, summaryResult);
}
}
/// <summary>
/// Copnstroi o sumário da busca realizada
/// </summary>
/// <param name="summaryList">Lista de elementos retornados pela busca</param>
/// <param name="channel">Canal</param>
/// <returns>Lista se resultado de sumário</returns>
public SummaryResult[] BuildSummary(IEnumerable <Element> summaryList, Channel channel, string searchString)
{
if (_cache.ContainsKey(searchString))
{
return(_cache[searchString]);
}
else
{
SummaryResult[] result;
Dictionary <string, Dictionary <string, int> > summary = new Dictionary <string, Dictionary <string, int> >();
foreach (Element currentElement in summaryList)
{
foreach (SchemeIndex currentSchemeIndex in channel.Scheme.Indexes)
{
string IndexDescription = currentSchemeIndex.IndexDescription;
if (currentSchemeIndex.IncludeInSummary)
{
foreach (SchemeField currentSchemeField in currentSchemeIndex.FieldSchema)
{
string text = channel.Scheme.ValueHandle(currentSchemeField.FieldName)(currentElement);
if (!String.IsNullOrEmpty(text))
{
if (summary.ContainsKey(IndexDescription))
{
if (summary[IndexDescription].ContainsKey(text))
{
summary[IndexDescription][text]++;
}
else
{
summary[IndexDescription].Add(text, 1);
}
}
else
{
summary.Add(IndexDescription, new Dictionary <string, int>());
summary[IndexDescription].Add(text, 1);
}
}
}
}
}
}
result = new SummaryResult[summary.Count];
int index = 0;
foreach (string currentKey in summary.Keys)
{
result[index] = new SummaryResult(currentKey, summary[currentKey]);
index++;
}
lock (_cache)
{
if (!_cache.ContainsKey(searchString))
{
_cache.Add(searchString, result);
}
}
return(result);
}
}
/// <summary>
/// Renderes the PNG.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
/// <param name="lineCoverage">Indicates whether line coverage or branch coverage should be displayed.</param>
/// <returns>The rendered PNG.</returns>
private byte[] CreatePngBadge(SummaryResult summaryResult, bool lineCoverage)
{
string template = lineCoverage ? LineCoveragePngTemplate : BranchCoveragePngTemplate;
string text = "N/A";
decimal?coverage = lineCoverage ? summaryResult.CoverageQuota : summaryResult.BranchCoverageQuota;
if (coverage.HasValue)
{
coverage = Math.Floor(coverage.Value);
text = $"{coverage.Value.ToString(CultureInfo.InvariantCulture)}%";
}
using (var ms = new MemoryStream(Convert.FromBase64String(template)))
using (var image = Image.Load <Rgba32>(ms))
using (MemoryStream output = new MemoryStream())
{
Font font = null;
try
{
font = SystemFonts.CreateFont("Arial", 12, FontStyle.Regular);
}
catch (SixLabors.Fonts.Exceptions.FontFamilyNotFoundException)
{
throw new InvalidOperationException(Resources.ErrorFontNotFound);
}
image.Mutate(ctx => ctx.DrawText(text, font, Color.White, new PointF(113, 3)));
image.Save(output, new PngEncoder());
return(output.ToArray());
}
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="reportRenderer">The report renderer.</param>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(IReportRenderer reportRenderer, SummaryResult summaryResult)
{
if (reportRenderer == null)
{
throw new ArgumentNullException(nameof(reportRenderer));
}
if (summaryResult == null)
{
throw new ArgumentNullException(nameof(summaryResult));
}
reportRenderer.BeginSummaryReport(this.TargetDirectory, "CoverageHistory.htm", ReportResources.Summary);
var historicCoverages = this.GetOverallHistoricCoverages(summaryResult.Assemblies.SelectMany(a => a.Classes));
if (historicCoverages.Any(h => h.CoverageQuota.HasValue || h.BranchCoverageQuota.HasValue))
{
reportRenderer.Chart(historicCoverages);
}
reportRenderer.CustomSummary(summaryResult.Assemblies, summaryResult.SupportsBranchCoverage);
reportRenderer.SaveSummaryReport(this.TargetDirectory);
}
/// <summary>
/// Renderes the SVG.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
/// <param name="includeLineCoverage">Indicates whether line coverage should be included.</param>
/// <param name="includeBranchCoverage">Indicates whether branch coverage should be included.</param>
/// <returns>The rendered SVG.</returns>
private string CreateSvgBadge(SummaryResult summaryResult, bool includeLineCoverage, bool includeBranchCoverage)
{
string lineCoverageClass = includeLineCoverage && includeBranchCoverage ? "linecoverage" : string.Empty;
string branchCoverageClass = includeLineCoverage && includeBranchCoverage ? "branchcoverage" : string.Empty;
string lineCoverage = "N/A";
string branchCoverage = "N/A";
if (summaryResult.CoverageQuota.HasValue)
{
lineCoverage = $"{summaryResult.CoverageQuota.Value.ToString(CultureInfo.InvariantCulture)}%";
}
if (summaryResult.BranchCoverageQuota.HasValue)
{
branchCoverage = $"{summaryResult.BranchCoverageQuota.Value.ToString(CultureInfo.InvariantCulture)}%";
}
return(string.Format(
Template,
ReportResources.CodeCoverage,
includeLineCoverage ? string.Format(LineCoverageSymbol, lineCoverageClass) : string.Empty,
includeBranchCoverage ? string.Format(BranchCoverageSymbol, branchCoverageClass) : string.Empty,
$"{ReportResources.GeneratedBy} ReportGenerator {typeof(IReportBuilder).Assembly.GetName().Version}",
ReportResources.Coverage3,
includeLineCoverage ? string.Format(CoverageText, lineCoverageClass, lineCoverage) : string.Empty,
includeBranchCoverage ? string.Format(CoverageText, branchCoverageClass, branchCoverage) : string.Empty,
includeLineCoverage ? string.Format(CoverageTooltip, lineCoverageClass, ReportResources.Coverage) : string.Empty,
includeBranchCoverage ? string.Format(CoverageTooltip, branchCoverageClass, ReportResources.BranchCoverage) : string.Empty));
}
protected override void EncodeEntry(Uri requestUrl, object loc, SummaryResult result, XmlWriter xmlWriter)
{
base.EncodeEntry(requestUrl, loc, result, xmlWriter);
long totalMetadataSize = result.TotalMetadataSize;
xmlWriter.WriteElementString("TotalMetadataSize", totalMetadataSize.ToString(CultureInfo.InvariantCulture));
}
public void WarningCountProperty_OnGet_GetsTheNumberOfWarnings()
{
var summaryResult = new SummaryResult
{
Analysis = new Analysis()
{
Results = new List <AnalyzeResult>()
{
new AnalyzeResult()
{
ResultRules = new List <ResultRule>()
{
new ResultRule()
{
Alias = "rule 1", Type = ResultType.Warning
},
new ResultRule()
{
Alias = "rule 2", Type = ResultType.Warning
}
}
}
}
}
};
var result = summaryResult.WarningCount;
Assert.AreEqual(2, result);
}
public void AnalysisProperty_OnSet_SetsTheValueToNull()
{
var summaryResult = new SummaryResult();
summaryResult.Analysis = null;
Assert.IsNull(summaryResult.Analysis);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(false, true, this.javaScriptContent))
{
this.CreateSummaryReport(renderer, summaryResult);
}
}
private void DrawSummary(Graphics g, SummaryResult summary)
{
if (g == null || summary == null)
{
return;
}
StringFormat align = new StringFormat();
align.Alignment = StringAlignment.Center;
// draw MHS total
Font font = new Font(_fontName, _MHSDrawInfos[0].FontSize, FontStyle.Bold);
Brush brush = new SolidBrush(_MHSDrawInfos[0].FontColor);
g.DrawString(SafeGHS(summary.Summary.GetCurGHS()).ToString(), font, brush, _MHSDrawInfos[0].Rect, align);
// draw MHS av
font = new Font(_fontName, _MHSDrawInfos[1].FontSize, FontStyle.Bold);
brush = new SolidBrush(_MHSDrawInfos[1].FontColor);
g.DrawString(SafeGHS(summary.Summary.GetGHSAv()).ToString(), font, brush, _MHSDrawInfos[1].Rect, align);
// draw MHS 300s
font = new Font(_fontName, _MHSDrawInfos[2].FontSize, FontStyle.Bold);
brush = new SolidBrush(_MHSDrawInfos[2].FontColor);
g.DrawString(SafeGHS(summary.Summary.GetGHSByInterval(_appConfig.MHSSeconds)).ToString(), font, brush, _MHSDrawInfos[2].Rect, align);
}
public void ShouldSummarizingCorrectTheFileIfExists()
{
var filePath = Directory.GetFiles(PathConfigurations.RootPathIn,
"File_Processor_Test.20190103.dat", SearchOption.AllDirectories).FirstOrDefault();
var abstractLine1 = base.ParserHelper("001ç1234567891234çDiegoç50000");
var abstractLine2 = base.ParserHelper("001ç3245678865434çRenatoç40000.99");
var abstractLine3 = base.ParserHelper("002ç2345675434544345çJosedaSilvaçRural");
var abstractLine4 = base.ParserHelper("002ç2345675433444345çEduardoPereiraçRural");
var abstractLine5 = base.ParserHelper("003ç10ç[1-10-100,2-30-2.50,3-40-3.10]çDiego");
var abstractLine6 = base.ParserHelper("003ç08ç[1-34-10,2-33-1.50,3-40-0.10]çRenato");
_dataParserHelper.Setup(x => x.Parser("001ç1234567891234çDiegoç50000")).Returns(abstractLine1);
_dataParserHelper.Setup(x => x.Parser("001ç3245678865434çRenatoç40000.99")).Returns(abstractLine2);
_dataParserHelper.Setup(x => x.Parser("002ç2345675434544345çJosedaSilvaçRural")).Returns(abstractLine3);
_dataParserHelper.Setup(x => x.Parser("002ç2345675433444345çEduardoPereiraçRural")).Returns(abstractLine4);
_dataParserHelper.Setup(x => x.Parser("003ç10ç[1-10-100,2-30-2.50,3-40-3.10]çDiego")).Returns(abstractLine5);
_dataParserHelper.Setup(x => x.Parser("003ç08ç[1-34-10,2-33-1.50,3-40-0.10]çRenato")).Returns(abstractLine6);
var summaryResult = new SummaryResult
{
AmoutClients = 2,
AmoutSalesman = 2,
IdExpensiveSale = "10",
WorstSalesman = "Renato",
FileName = "File_Processor_Test.20190103.done.dat"
};
var summaryResponse = _fileProcessor.SummarizeFile(filePath);
summaryResponse.Should().Be(summaryResult);
}
public void ShouldProcessTheFiles()
{
var filesTest = new List <string>
{
"Test.dat"
};
var summaryResult = new SummaryResult
{
AmoutClients = 1,
AmoutSalesman = 1,
FileName = "Test.dat",
IdExpensiveSale = "1a",
WorstSalesman = "fulano"
};
var fileProcessing = Path.Combine(PathConfigurations.RootPathProcessing, filesTest[0]);
_fileManagementMock.Setup(x => x.Scanner()).Returns(filesTest);
_fileManagementMock.Setup(x => x.MoveForProcessing(filesTest[0])).Returns(fileProcessing);
var response = _fileProcessorMock.Setup(x => x.SummarizeFile(fileProcessing)).Returns(summaryResult);
_fileManagementMock.Setup(x => x.SaveFile(summaryResult));
_fileProcessingService.ProcessFiles();
_fileManagementMock.Verify(x => x.Scanner(), Times.Once);
_fileManagementMock.Verify(x => x.MoveForProcessing(filesTest[0]), Times.Once);
_fileProcessorMock.Verify(x => x.SummarizeFile(fileProcessing), Times.Once);
_fileManagementMock.Verify(x => x.SaveFile(summaryResult), Times.Once);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="reportRenderer">The report renderer.</param>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(IReportRenderer reportRenderer, SummaryResult summaryResult)
{
if (reportRenderer == null)
{
throw new ArgumentNullException(nameof(reportRenderer));
}
if (summaryResult == null)
{
throw new ArgumentNullException(nameof(summaryResult));
}
reportRenderer.BeginSummaryReport(this.ReportContext.ReportConfiguration.TargetDirectory, "CoverageHistory.html", ReportResources.Summary);
var historicCoverages = this.GetOverallHistoricCoverages(this.ReportContext.OverallHistoricCoverages);
if (historicCoverages.Any(h => h.CoverageQuota.HasValue || h.BranchCoverageQuota.HasValue))
{
reportRenderer.Chart(historicCoverages, this.ReportContext.Settings.RenderPngFallBackImagesForHistoryCharts);
}
reportRenderer.CustomSummary(summaryResult.Assemblies, new List <RiskHotspot>(), summaryResult.SupportsBranchCoverage);
reportRenderer.SaveSummaryReport(this.ReportContext.ReportConfiguration.TargetDirectory);
File.Copy(
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "CoverageHistory.html"),
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "CoverageHistory.htm"),
true);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(false, true, "custom-azurepipelines.css", "custom-azurepipelines_dark.css"))
{
this.CreateSummaryReport(renderer, summaryResult);
}
}
public void AliasProperty_OnSet_SetsTheValue()
{
var summaryResult = new SummaryResult();
summaryResult.Alias = "alias";
Assert.AreEqual("alias", summaryResult.Alias);
}
/// <summary>
/// Renderes the PNG.
/// </summary>
/// <param name="summaryResult">Indicates whether </param>
/// <param name="lineCoverage">Indicates whether line coverage or branch coverage should be displayed.</param>
/// <returns>The rendered PNG.</returns>
private byte[] CreatePngBadge(SummaryResult summaryResult, bool lineCoverage)
{
string template = lineCoverage ? LineCoveragePngTemplate : BranchCoveragePngTemplate;
string text = (lineCoverage ? summaryResult.CoverageQuota.Value : summaryResult.BranchCoverageQuota.Value).ToString(CultureInfo.InvariantCulture) + "%";
using (var ms = new MemoryStream(Convert.FromBase64String(template)))
using (Image image = Bitmap.FromStream(ms))
using (Graphics g = Graphics.FromImage(image))
using (Font font = new Font("Verdana", 8, FontStyle.Regular, GraphicsUnit.Point))
using (MemoryStream output = new MemoryStream())
{
Rectangle rect = new Rectangle(112, 0, 155, 20);
StringFormat stringFormat = new StringFormat()
{
Alignment = StringAlignment.Near,
LineAlignment = StringAlignment.Center
};
g.DrawString(text, font, Brushes.White, rect, stringFormat);
image.Save(output, ImageFormat.Png);
return(output.ToArray());
}
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
if (summaryResult == null)
{
throw new ArgumentNullException(nameof(summaryResult));
}
if (summaryResult.CoverageQuota.HasValue)
{
File.WriteAllText(
Path.Combine(this.TargetDirectory, "badge_linecoverage.svg"),
this.CreateBadge(summaryResult, true, false));
}
if (summaryResult.BranchCoverageQuota.HasValue)
{
File.WriteAllText(
Path.Combine(this.TargetDirectory, "badge_branchcoverage.svg"),
this.CreateBadge(summaryResult, false, true));
}
if (summaryResult.CoverageQuota.HasValue && summaryResult.BranchCoverageQuota.HasValue)
{
File.WriteAllText(
Path.Combine(this.TargetDirectory, "badge_combined.svg"),
this.CreateBadge(summaryResult, true, true));
}
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
if (summaryResult == null)
{
throw new ArgumentNullException(nameof(summaryResult));
}
string targetPath = Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "Summary.txt");
using (var reportTextWriter = new StreamWriter(new FileStream(targetPath, FileMode.Create), Encoding.UTF8))
{
reportTextWriter.WriteLine(ReportResources.Summary);
reportTextWriter.WriteLine(" {0} {1}", ReportResources.GeneratedOn, DateTime.Now.ToShortDateString() + " - " + DateTime.Now.ToLongTimeString());
reportTextWriter.WriteLine(" {0} {1}", ReportResources.Parser, summaryResult.UsedParser);
reportTextWriter.WriteLine(" {0} {1}", ReportResources.Assemblies2, summaryResult.Assemblies.Count().ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.Classes, summaryResult.Assemblies.SelectMany(a => a.Classes).Count().ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.Files2, summaryResult.Assemblies.SelectMany(a => a.Classes).SelectMany(a => a.Files).Distinct().Count().ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.Coverage2, summaryResult.CoverageQuota.HasValue ? summaryResult.CoverageQuota.Value.ToString("f1", CultureInfo.InvariantCulture) + "%" : string.Empty);
reportTextWriter.WriteLine(" {0} {1}", ReportResources.CoveredLines, summaryResult.CoveredLines.ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.UncoveredLines, (summaryResult.CoverableLines - summaryResult.CoveredLines).ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.CoverableLines, summaryResult.CoverableLines.ToString(CultureInfo.InvariantCulture));
reportTextWriter.WriteLine(" {0} {1}", ReportResources.TotalLines, summaryResult.TotalLines.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
if (summaryResult.Assemblies.Any())
{
var maximumNameLength = summaryResult.Assemblies
.SelectMany(a => a.Classes).Select(c => c.Name)
.Union(summaryResult.Assemblies.Select(a => a.Name))
.Max(n => n.Length);
foreach (var assembly in summaryResult.Assemblies)
{
string assemblyQuota = assembly.CoverageQuota.HasValue ? assembly.CoverageQuota.Value.ToString("f1", CultureInfo.InvariantCulture) + "%" : string.Empty;
reportTextWriter.WriteLine();
reportTextWriter.WriteLine(
"{0}{1} {2}",
assembly.Name,
new string(' ', maximumNameLength - assembly.Name.Length + 8 - assemblyQuota.Length),
assemblyQuota);
foreach (var @class in assembly.Classes)
{
string classQuota = @class.CoverageQuota.HasValue ? @class.CoverageQuota.Value.ToString("f1", CultureInfo.InvariantCulture) + "%" : string.Empty;
reportTextWriter.WriteLine(
" {0}{1} {2}",
@class.Name,
new string(' ', maximumNameLength - @class.Name.Length + 6 - classQuota.Length),
classQuota);
}
}
}
else
{
reportTextWriter.WriteLine(ReportResources.NoCoveredAssemblies);
}
reportTextWriter.Flush();
}
}
private void UpdateSummary(SummaryResult summary)
{
_currentSummaryResult = summary;
_avalonFloatWindow.CurMHS = SafeGHS(summary.Summary.GetCurGHS());
SafeControlUpdater.Invalidate(this.pictureBoxGraph);
_avalonFloatWindow.Invalidate();
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
this.htmlReportBuilder.CreateSummaryReport(summaryResult);
this.CreateMhtmlFile();
Directory.Delete(this.htmlReportTargetDirectory, true);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
string targetPath = Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "SonarQube.xml");
Logger.InfoFormat(" " + Resources.WritingReportFile, targetPath);
this.document.Save(targetPath);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
foreach (var assembly in summaryResult.Assemblies)
{
if (this.packageElementsByName.TryGetValue(assembly.Name, out XElement packageElement))
{
double packageLineRate = assembly.CoverableLines == 0 ? 1 : assembly.CoveredLines / (double)assembly.CoverableLines;
double packageBranchRate = assembly.TotalBranches.GetValueOrDefault() == 0 ? 1 : assembly.CoveredBranches.GetValueOrDefault() / (double)assembly.TotalBranches.GetValueOrDefault();
packageElement.Add(new XAttribute("line-rate", packageLineRate.ToString(CultureInfo.InvariantCulture)));
packageElement.Add(new XAttribute("branch-rate", packageBranchRate.ToString(CultureInfo.InvariantCulture)));
packageElement.Add(new XAttribute("complexity", "NaN"));
}
}
double lineRate = summaryResult.CoverableLines == 0 ? 1 : summaryResult.CoveredLines / (double)summaryResult.CoverableLines;
double branchRate = summaryResult.TotalBranches.GetValueOrDefault() == 0 ? 1 : summaryResult.CoveredBranches.GetValueOrDefault() / (double)summaryResult.TotalBranches.GetValueOrDefault();
var rootElement = new XElement("coverage");
rootElement.Add(new XAttribute("line-rate", lineRate.ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("branch-rate", branchRate.ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("lines-covered", summaryResult.CoveredLines.ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("lines-valid", summaryResult.CoverableLines.ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("branches-covered", summaryResult.CoveredBranches.GetValueOrDefault().ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("branches-valid", summaryResult.TotalBranches.GetValueOrDefault().ToString(CultureInfo.InvariantCulture)));
rootElement.Add(new XAttribute("complexity", "NaN"));
rootElement.Add(new XAttribute("version", 0));
rootElement.Add(new XAttribute("timestamp", ((long)(DateTime.Now - new DateTime(1970, 1, 1)).TotalSeconds).ToString(CultureInfo.InvariantCulture)));
var sourcesElement = new XElement("sources");
foreach (var sourceDirectory in summaryResult.SourceDirectories)
{
sourcesElement.Add(new XElement("source", sourceDirectory));
}
rootElement.Add(sourcesElement);
var packagesElement = new XElement("packages");
foreach (var packageElement in this.packageElementsByName.Values)
{
packagesElement.Add(packageElement);
}
rootElement.Add(packagesElement);
XDocument result = new XDocument(new XDeclaration("1.0", null, null), rootElement);
result.AddFirst(new XDocumentType("coverage", null, "http://cobertura.sourceforge.net/xml/coverage-04.dtd", null));
string targetPath = Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "Cobertura.xml");
Logger.InfoFormat(Resources.WritingReportFile, targetPath);
result.Save(targetPath);
}
protected override void EncodeEntry(Uri requestUrl, object loc, SummaryResult result, XmlWriter xmlWriter)
{
ListBlobSummaryResult listBlobSummaryResult = result as ListBlobSummaryResult;
xmlWriter.WriteElementString("Count", listBlobSummaryResult.Count.ToString());
xmlWriter.WriteElementString("TotalContentSize", listBlobSummaryResult.TotalContentSize.ToString());
xmlWriter.WriteElementString("NextContainerName", listBlobSummaryResult.NextContainerName);
xmlWriter.WriteElementString("NextBlobName", listBlobSummaryResult.NextBlobName);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="reportRenderer">The report renderer.</param>
/// <param name="summaryResult">The summary result.</param>
public virtual void CreateAssemblyReport(IReportRenderer reportRenderer, SummaryResult summaryResult, Assembly anAssembly)
{
if (reportRenderer == null)
{
throw new ArgumentNullException(nameof(reportRenderer));
}
if (summaryResult == null)
{
throw new ArgumentNullException(nameof(summaryResult));
}
if (anAssembly == null)
{
throw new ArgumentNullException(nameof(anAssembly));
}
string title = this.ReportContext.ReportConfiguration.Title != null ? $"{ReportResources.Summary} - {this.ReportContext.ReportConfiguration.Title}" : ReportResources.Summary;
title = anAssembly.Name;
reportRenderer.BeginSummaryReport(this.ReportContext.ReportConfiguration.TargetDirectory, HtmlRenderer.GetAssemblyReportFilename(anAssembly.Name), title);
reportRenderer.HeaderWithGithubLinks(title);
reportRenderer.BeginKeyValueTable();
reportRenderer.KeyValueRow(ReportResources.GeneratedOn, DateTime.Now.ToShortDateString() + " - " + DateTime.Now.ToLongTimeString());
reportRenderer.KeyValueRow(ReportResources.Classes, Convert.ToString(anAssembly.Classes.Count(), CultureInfo.InvariantCulture));
reportRenderer.KeyValueRow(ReportResources.Files2, anAssembly.Classes.SelectMany(a => a.Files).Distinct().Count().ToString(CultureInfo.InvariantCulture));
reportRenderer.KeyValueRow(ReportResources.CoveredLines, anAssembly.CoverableLines.ToString(CultureInfo.InvariantCulture));
reportRenderer.KeyValueRow(ReportResources.UncoveredLines, (anAssembly.CoverableLines - anAssembly.CoveredLines).ToString(CultureInfo.InvariantCulture));
reportRenderer.KeyValueRow(ReportResources.CoverableLines, anAssembly.CoverableLines.ToString(CultureInfo.InvariantCulture));
reportRenderer.KeyValueRow(ReportResources.TotalLines, anAssembly.TotalLines.GetValueOrDefault().ToString(CultureInfo.InvariantCulture));
reportRenderer.FinishTable();
reportRenderer.Header(ReportResources.Coverage3);
reportRenderer.BeginSummaryTable();
reportRenderer.BeginSummaryTable(summaryResult.SupportsBranchCoverage);
reportRenderer.SummaryAssembly(anAssembly, summaryResult.SupportsBranchCoverage);
foreach (var codeFile in anAssembly.Classes.SelectMany(c => c.Files).Distinct())
{
reportRenderer.SummaryFile(codeFile, summaryResult.SupportsBranchCoverage);
}
reportRenderer.FinishTable();
reportRenderer.FinishSummaryTable();
reportRenderer.CustomSummary(summaryResult.Assemblies, this.ReportContext.RiskHotspotAnalysisResult.RiskHotspots, summaryResult.SupportsBranchCoverage);
reportRenderer.AddFooter();
reportRenderer.SaveSummaryReport(this.ReportContext.ReportConfiguration.TargetDirectory);
}
private void ParseSummary()
{
List <string> output = LoadOutput();
SummaryResult result = NUnitParser.ParseSummary(output);
Assert.Equal("5", result.TotalCount);
Assert.Equal("1", result.PassCount);
Assert.Equal("4", result.FailCount);
Assert.Equal("1", result.SkipCount);
Assert.Equal(String.Empty, result.Duration);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(false, HtmlMode.InlineCssAndJavaScript, "custom-azurepipelines.css"))
{
this.CreateSummaryReport(renderer, summaryResult);
}
File.Copy(
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "index.html"),
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "index.htm"),
true);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public void CreateSummaryReport(SummaryResult summaryResult)
{
var allClasses = summaryResult.Assemblies
.SelectMany(x => x.Classes)
.Where(x => x.CoverableLines > 0)
.ToList();
WriteStatistics('S', summaryResult.CoveredLines, summaryResult.CoverableLines);
WriteStatistics('R', summaryResult.CoveredBranches.GetValueOrDefault(), summaryResult.TotalBranches.GetValueOrDefault());
WriteStatistics('C', allClasses.Count(y => y.CoveredLines > 0), allClasses.Count);
WriteStatistics('M', summaryResult.CoveredCodeElements, summaryResult.TotalCodeElements);
}
/// <summary>
/// Creates the summary report.
/// </summary>
/// <param name="summaryResult">The summary result.</param>
public override void CreateSummaryReport(SummaryResult summaryResult)
{
using (var renderer = new HtmlRenderer(false, this.htmlMode))
{
this.CreateSummaryReport(renderer, summaryResult);
}
File.Copy(
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "index.html"),
Path.Combine(this.ReportContext.ReportConfiguration.TargetDirectory, "index.htm"),
true);
}
public static CustomJsonCoverageResult Create(SummaryResult summaryResult)
{
return(new CustomJsonCoverageResult
{
Coverage = new JsonCoverageCoverage {
},
Summary = new JsonCoverageSummary {
GeneratedOn = DateTime.Now.ToUniversalTime(),
Parser = summaryResult.UsedParser
}
});
}
