/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="module">The module.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private static Assembly ProcessAssembly(XElement module)
{
string assemblyName = module.Attribute("name").Value;
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = module
.Elements("functions")
.Elements("function")
.Select(f => f.Attribute("type_name").Value)
.Where(c => !c.Contains("<>")
&& !c.StartsWith("$", StringComparison.OrdinalIgnoreCase))
.Select(t =>
{
int nestedClassSeparatorIndex = t.IndexOf('.');
return nestedClassSeparatorIndex > -1 ? t.Substring(0, nestedClassSeparatorIndex) : t;
})
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(ProcessClass(module, assembly, className)));
return assembly;
}
public void AddClass_AddSingleClass_ClassIsStored()
{
var sut = new Assembly("C:\\test\\TestAssembly.dll");
var @class = new Class("Test", sut);
sut.AddClass(@class);
Assert.AreEqual(@class, sut.Classes.First(), "Not equal");
Assert.AreEqual(1, sut.Classes.Count(), "Wrong number of classes");
}
public void Merge_MergeAssemblyWithOneClass_ClassIsStored()
{
var sut = new Assembly("C:\\test\\TestAssembly.dll");
var assemblyToMerge = new Assembly("C:\\test\\TestAssembly.dll");
var @class = new Class("Test", sut);
assemblyToMerge.AddClass(@class);
sut.Merge(assemblyToMerge);
Assert.AreEqual(@class, sut.Classes.First(), "Not equal");
Assert.AreEqual(1, sut.Classes.Count(), "Wrong number of classes");
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.types
.Where(type => type.Attribute("asm").Value.Equals(assemblyName) && !type.Attribute("name").Value.Contains("__"))
.Select(type => type.Attribute("name").Value)
.OrderBy(name => name)
.Distinct()
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return assembly;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.modules
.Where(module => module.Attribute("assembly").Value.Equals(assemblyName))
.Elements("method")
.Select(method => method.Attribute("class").Value)
.Where(value => !value.Contains("__"))
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return assembly;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="module">The module.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private static Assembly ProcessAssembly(XElement module)
{
string assemblyName = module.Attribute("name").Value;
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = module
.Elements("functions")
.Elements("function")
.Select(f => f.Attribute("type_name").Value)
.Where(c => !c.Contains("__")
&& !c.Contains("<")
&& !c.Contains("."))
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(ProcessClass(module, assembly, className)));
return assembly;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var assemblyElement = this.modules
.Where(m => m.Attribute("Name").Value.Equals(assemblyName));
var classNames = assemblyElement
.Elements("Namespace")
.Elements("Type")
.Concat(assemblyElement.Elements("Type"))
.Where(c => !c.Attribute("Name").Value.Contains("__"))
.Select(c => c.Parent.Attribute("Name").Value + "." + c.Attribute("Name").Value)
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return assembly;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var fileIdsByFilename = this.modules
.Where(m => m.Element("ModuleName").Value.Equals(assemblyName))
.Elements("Files")
.Elements("File")
.GroupBy(f => f.Attribute("fullPath").Value, f => f.Attribute("uid").Value)
.ToDictionary(g => g.Key, g => g.ToHashSet());
var classNames = this.modules
.Where(m => m.Element("ModuleName").Value.Equals(assemblyName))
.Elements("Classes")
.Elements("Class")
.Where(c => !c.Element("FullName").Value.Contains("__")
&& !c.Element("FullName").Value.Contains("<")
&& c.Attribute("skippedDueTo") == null)
.Select(c =>
{
string fullname = c.Element("FullName").Value;
int nestedClassSeparatorIndex = fullname.IndexOf('/');
return nestedClassSeparatorIndex > -1 ? fullname.Substring(0, nestedClassSeparatorIndex) : fullname;
})
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(fileIdsByFilename, assembly, className)));
return assembly;
}
/// <summary>
/// Processes the given assembly.
/// </summary>
/// <param name="assemblyName">Name of the assembly.</param>
/// <returns>The <see cref="Assembly"/>.</returns>
private Assembly ProcessAssembly(string assemblyName)
{
Logger.DebugFormat(" " + Resources.CurrentAssembly, assemblyName);
var classNames = this.modules
.Where(m => m.Element("ModuleName").Value.Equals(assemblyName))
.Elements("NamespaceTable")
.Elements("Class")
.Elements("ClassName")
.Where(c => !c.Value.Contains("<>")
&& !c.Value.StartsWith("$", StringComparison.OrdinalIgnoreCase))
.Select(c =>
{
string fullname = c.Value;
int nestedClassSeparatorIndex = fullname.IndexOf('.');
fullname = nestedClassSeparatorIndex > -1 ? fullname.Substring(0, nestedClassSeparatorIndex) : fullname;
return c.Parent.Parent.Element("NamespaceName").Value + "." + fullname;
})
.Distinct()
.OrderBy(name => name)
.ToArray();
var assembly = new Assembly(assemblyName);
Parallel.ForEach(classNames, className => assembly.AddClass(this.ProcessClass(assembly, className)));
return assembly;
}
/// <summary>
/// Starts the generation of the report.
/// </summary>
/// <param name="addHistoricCoverage">if set to <c>true</c> historic coverage information is added to classes.</param>
/// <param name="executionTime">The execution time.</param>
internal void CreateReport(bool addHistoricCoverage, DateTime executionTime)
{
var filteredAssemblies = this.parser.Assemblies
.Where(a => this.assemblyFilter.IsElementIncludedInReport(a.Name))
.Select(a =>
{
var newAssembly = new Assembly(a.Name);
foreach (var @class in a.Classes)
{
if (classFilter.IsElementIncludedInReport(@class.Name))
{
newAssembly.AddClass(@class);
}
}
return newAssembly;
});
int numberOfClasses = filteredAssemblies.Sum(a => a.Classes.Count());
Logger.InfoFormat(Resources.AnalyzingClasses, numberOfClasses);
int counter = 0;
foreach (var assembly in filteredAssemblies)
{
foreach (var @class in assembly.Classes)
{
counter++;
Logger.DebugFormat(
CultureInfo.InvariantCulture,
" " + Resources.CreatingReport,
counter,
numberOfClasses,
@class.Assembly.ShortName,
@class.Name);
foreach (var renderer in this.renderers)
{
var fileAnalyses = @class.Files.Select(f => f.AnalyzeFile()).ToArray();
try
{
if (addHistoricCoverage)
{
@class.AddHistoricCoverage(new HistoricCoverage(@class, executionTime));
}
renderer.CreateClassReport(@class, fileAnalyses);
}
catch (Exception ex)
{
Logger.ErrorFormat(
CultureInfo.InvariantCulture,
" " + Resources.ErrorDuringRenderingClassReport,
@class.Name,
renderer.ReportType,
ex.Message);
}
}
}
}
Logger.Debug(" " + Resources.CreatingSummary);
SummaryResult summaryResult = new SummaryResult(filteredAssemblies, this.parser.ToString());
foreach (var renderer in this.renderers)
{
try
{
renderer.CreateSummaryReport(summaryResult);
}
catch (Exception ex)
{
Logger.ErrorFormat(
CultureInfo.InvariantCulture,
" " + Resources.ErrorDuringRenderingSummaryReport,
renderer.ReportType,
ex.Message);
}
}
}
private IEnumerable<Assembly> ProcessAssemblies()
{
var assemblies = this.coverageData.GroupBy (x => x.Assembly);
foreach (var assemblyData in assemblies)
{
Assembly assembly = new Assembly (assemblyData.Key);
foreach (var cd in ProcessClasses (assembly, assemblyData.ToList()))
assembly.AddClass (cd);
yield return assembly;
}
}
