public void ClassConstructorTest()
{
string assemblyname = "C:\\test\\TestAssembly.dll";
string classname = "TestClass";
var target = new Class(assemblyname, classname);
Assert.AreEqual(assemblyname, target.AssemblyName, "Not equal");
Assert.AreEqual("TestAssembly.dll", target.ShortAssemblyName, "Not equal");
Assert.AreEqual(classname, target.Name, "Not equal");
}
public void EqualsTest()
{
string assemblyname = "TestAssembly";
string classname = "TestClass";
var target1 = new Class(assemblyname, classname);
var target2 = new Class(assemblyname, classname);
Assert.IsTrue(target1.Equals(target2), "Objects are not equal");
Assert.IsFalse(target1.Equals(null), "Objects are equal");
Assert.IsFalse(target1.Equals(new object()), "Objects are equal");
}
/// <summary>
/// Starts the generation of the report.
/// </summary>
public void CreateReport()
{
int numberOfClasses = 0;
var assemblies = new List<Assembly>();
foreach (var assemblyName in this.parser.Assemblies())
{
var assembly = new Assembly(assemblyName);
var classes = this.parser.ClassesInAssembly(assemblyName);
foreach (var className in classes)
{
var clazz = new Class(assembly.Name, className);
assembly.AddClass(clazz);
numberOfClasses++;
}
assemblies.Add(assembly);
}
logger.InfoFormat("Analyzing {0} classes", numberOfClasses);
int counter = 0;
if (this.rendererFactory.SupportsParallelClassReports)
{
Parallel.ForEach(
assemblies,
(assembly) =>
{
Parallel.ForEach(
assembly.Classes,
(clazz) =>
{
int current = Interlocked.Increment(ref counter);
logger.InfoFormat(
CultureInfo.InvariantCulture,
" Creating report {0}/{1} (Assembly: {2}, Class: {3})",
current,
numberOfClasses,
clazz.AssemblyName,
clazz.Name);
this.CreateClassReport(clazz);
});
});
}
else
{
foreach (var assembly in assemblies)
{
foreach (var clazz in assembly.Classes)
{
logger.DebugFormat(
CultureInfo.InvariantCulture,
" Creating report {0}/{1} (Assembly: {2}, Class: {3})",
++counter,
numberOfClasses,
clazz.AssemblyName,
clazz.Name);
this.CreateClassReport(clazz);
}
}
}
this.CreateSummary(assemblies);
}
/// <summary>
/// Adds the coverage information of a class to the report.
/// </summary>
/// <param name="clazz">The class.</param>
public void SummaryClass(Class clazz)
{
string row = string.Format(
CultureInfo.InvariantCulture,
@"{0} & {1}\%\\",
EscapeLatexChars(clazz.Name),
clazz.CoverageQuota);
this.reportBuilder.AppendLine(row);
}
/// <summary>
/// Creates the report for the given class.
/// </summary>
/// <param name="clazz">The class.</param>
private void CreateClassReport(Class clazz)
{
var files = this.parser.FilesOfClass(clazz.AssemblyName, clazz.Name);
var fileAnalysis = files.Select(f => this.AnalyzeFile(f, clazz)).ToArray();
if (!fileAnalysis.Any())
{
clazz.CoverageQuota = this.parser.GetCoverageQuotaOfClass(clazz.AssemblyName, clazz.Name);
clazz.CoverageType = CoverageType.MethodCoverage;
}
var classRenderer = this.rendererFactory.CreateClassRenderer();
if (classRenderer == null)
{
return;
}
classRenderer.BeginClassReport(clazz.Name);
classRenderer.Header("Summary");
classRenderer.BeginKeyValueTable();
classRenderer.KeyValueRow("Class:", clazz.Name);
classRenderer.KeyValueRow("Assembly:", clazz.ShortAssemblyName);
classRenderer.KeyValueRow("File(s):", files);
classRenderer.KeyValueRow("Coverage:", clazz.CoverageQuota.ToString(CultureInfo.InvariantCulture) + "%");
classRenderer.KeyValueRow("Covered lines:", clazz.CoveredLines.ToString(CultureInfo.InvariantCulture));
classRenderer.KeyValueRow("Coverable lines:", clazz.CoverableLines.ToString(CultureInfo.InvariantCulture));
classRenderer.KeyValueRow("Total lines:", clazz.TotalLines.ToString(CultureInfo.InvariantCulture));
classRenderer.FinishTable();
var metrics = this.parser.MethodMetrics(clazz.AssemblyName, clazz.Name);
if (metrics != null && metrics.Any())
{
classRenderer.Header("Metrics");
classRenderer.BeginMetricsTable(new[] { "Method" }.Union(metrics.First().Metrics.Select(m => m.Name)));
foreach (var metric in metrics)
{
classRenderer.MetricsRow(metric);
}
classRenderer.FinishTable();
}
classRenderer.Header("File(s)");
if (fileAnalysis.Any())
{
foreach (var file in fileAnalysis)
{
classRenderer.File(file.FileName);
if (!string.IsNullOrEmpty(file.Error))
{
classRenderer.Paragraph(file.Error);
}
else
{
classRenderer.BeginLineAnalysisTable(new[] { string.Empty, "#", "Line", "Coverage" });
foreach (var line in file.Lines)
{
classRenderer.LineAnalysis(line);
}
classRenderer.FinishTable();
}
}
}
else
{
classRenderer.Paragraph("No files found. This usually happens if a file isn't covered by a test or the class does not contain any sequence points (e.g. a class that only contains auto properties).");
}
classRenderer.SaveClassReport(this.targetDirectory, clazz.ShortAssemblyName, clazz.Name);
}
/// <summary>
/// Analyses a file and generates a coverage report of the file.
/// </summary>
/// <param name="fileName">The name of the file.</param>
/// <param name="clazz">The name of the assembly.</param>
/// <returns>The generated coverage report of the given file.</returns>
private FileAnalysis AnalyzeFile(string fileName, Class clazz)
{
if (!File.Exists(fileName))
{
string error = string.Format(CultureInfo.InvariantCulture, "File '{0}' does not exist (any more).", fileName);
logger.Error(error);
return new FileAnalysis(fileName, error);
}
try
{
string[] lines = File.ReadAllLines(fileName);
clazz.TotalLines += lines.Length;
int currentLineNumber = 0;
var result = new FileAnalysis(fileName);
foreach (var line in lines)
{
int visits = this.parser.NumberOfLineVisits(clazz.AssemblyName, clazz.Name, fileName, ++currentLineNumber);
if (visits == 0)
{
clazz.CoverableLines++;
}
else if (visits > 0)
{
clazz.CoveredLines++;
clazz.CoverableLines++;
}
result.AddLineAnalysis(new LineAnalysis(visits, currentLineNumber, line.TrimEnd()));
}
return result;
}
catch (IOException ex)
{
string error = string.Format(CultureInfo.InvariantCulture, "Error during reading file '{0}': {1}", fileName, ex.Message);
logger.Error(error);
return new FileAnalysis(fileName, error);
}
}
/// <summary>
/// Addes the given class to the assembly.
/// </summary>
/// <param name="clazz">The class to add.</param>
public void AddClass(Class clazz)
{
this.classes.Add(clazz);
}
/// <summary>
/// Adds the coverage information of a class to the report.
/// </summary>
/// <param name="clazz">The class.</param>
public void SummaryClass(Class clazz)
{
this.reportBuilder.AppendFormat(
CultureInfo.InvariantCulture,
"<tr class=\"classrow\"><td><a href=\"{0}\">{1}</a></td><td title=\"{2}\">{3}%</td><td>{4}</td></tr>",
WebUtility.HtmlEncode(ReplaceInvalidPathChars(clazz.ShortAssemblyName + "_" + clazz.Name) + ".htm"),
WebUtility.HtmlEncode(clazz.Name),
clazz.CoverageType,
clazz.CoverageQuota,
CreateCoverageTable(clazz.CoverageQuota));
}
/// <summary>
/// Adds the coverage information of a class to the report.
/// </summary>
/// <param name="clazz">The class.</param>
public void SummaryClass(Class clazz)
{
var coverage = new XElement(
"Class",
new XAttribute("name", clazz.Name),
new XAttribute("coverage", clazz.CoverageQuota),
new XAttribute("coveredlines", clazz.CoveredLines),
new XAttribute("coverablelines", clazz.CoverableLines),
new XAttribute("totallines", clazz.TotalLines));
this.currentAssembly.Add(coverage);
}
