public void AggregateLineCoverages()
{
var coverageRate = new CoverageRate(string.Empty, 0);
coverageRate.AddChild(CreateModule(
file1,
new LineCoverage(1, true),
new LineCoverage(2, true),
new LineCoverage(3, true),
new LineCoverage(4, false)));
coverageRate.AddChild(CreateModule(
file1,
new LineCoverage(2, true),
new LineCoverage(3, false),
new LineCoverage(4, false),
new LineCoverage(5, false)));
var aggregator = new FileCoverageAggregator();
var coverageByFile = aggregator.Aggregate(coverageRate, str => str);
var fileCoverage = coverageByFile.Single();
var expectedLineCoverages = new List <LineCoverage> {
new LineCoverage(1, true),
new LineCoverage(2, true),
new LineCoverage(3, true),
new LineCoverage(4, false),
new LineCoverage(5, false)
};
CollectionAssert.AreEqual(
expectedLineCoverages,
fileCoverage.Value.LineCoverages.ToList(),
new LineCoverageComparer());
}
//---------------------------------------------------------------------
System.Threading.Tasks.Task OnCoverageFinishedAsync(
System.Threading.Tasks.Task onCoverageFinished,
TemporaryFile coveragePath,
System.Threading.Tasks.Task avoidGCCollect)
{
return(errorHandler.ExecuteAsync(async() =>
{
using (coveragePath)
{
var exception = onCoverageFinished.Exception?.InnerExceptions.FirstOrDefault();
if (exception != null)
{
throw exception;
}
CoverageRate coverageRate = null;
if (File.Exists(coveragePath.Path))
{
coverageRate = BuildCoverageRate(coveragePath.Path);
}
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
OnCoverageRateBuilt(coverageRate, coveragePath.Path);
}
}));
}
//---------------------------------------------------------------------
public void ShowTreeCoverage(
DTE2 dte,
ICoverageViewManager coverageViewManager,
CoverageRate coverageRate)
{
ShowTreeCoverage(window => window.Controller.UpdateCoverageRate(
coverageRate, dte, coverageViewManager));
}
//---------------------------------------------------------------------
public Dictionary <string, FileCoverage> Aggregate(
CoverageRate coverageRate,
Func <string, string> normalizePath)
{
var fileCoverages = coverageRate.Children.SelectMany(module => module.Children);
return(CreateDictionary(
fileCoverages,
fileCoverage => normalizePath(fileCoverage.Path),
MergeFileCoverage));
}
//---------------------------------------------------------------------
void OnCoverageRateBuilt(CoverageRate coverageRate, string coveragePath)
{
if (coverageRate == null)
{
outputWindowWriter.WriteLine("The execution of the previous line failed." +
" Please execute the previous line in a promt" +
" command to have more information about the issue.");
throw new VSPackageException("Cannot generate coverage. See output pane for more information");
}
outputWindowWriter.WriteLine("Coverage written in " + coveragePath);
coverageTreeManager.ShowTreeCoverage(this.dte, this.coverageViewManager, coverageRate);
this.coverageViewManager.CoverageRate = coverageRate;
}
//---------------------------------------------------------------------
RootCoverageTreeNode CreateRoot(
string moduleName,
string file1,
string file2)
{
var module = new ModuleCoverage(moduleName);
module.AddChild(new FileCoverage(file1, new List <LineCoverage>()));
module.AddChild(new FileCoverage(file2, new List <LineCoverage>()));
var coverage = new CoverageRate("root", 0);
coverage.AddChild(module);
return(new RootCoverageTreeNode(coverage));
}
public void AggregateFileCoveragesOnly()
{
var coverageRate = new CoverageRate(string.Empty, 0);
coverageRate.AddChild(CreateModule(file1.ToUpper(), file2));
coverageRate.AddChild(CreateModule(file2.ToUpper(), file3.ToUpper()));
var aggregator = new FileCoverageAggregator();
var fileCoverageDict = aggregator.Aggregate(coverageRate, str => str.ToLower());
var fileCoverages = fileCoverageDict.Select(kvp => kvp.Key).ToList();
CollectionAssert.AreEquivalent(
new List <string> {
file1, file2, file3
}, fileCoverages);
}
//---------------------------------------------------------------------
public void ShowTreeCoverage(CoverageRate coverageRate)
{
var window = this.package.FindToolWindow(
typeof(CoverageTreeToolWindow), 0, true) as CoverageTreeToolWindow;
if (window == null || window.Frame == null)
{
throw new NotSupportedException("Cannot create tool window");
}
window.Controller.UpdateCoverageRate(
coverageRate, dte, this.coverageViewManager);
var frame = (IVsWindowFrame)window.Frame;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(frame.Show());
}
//-----------------------------------------------------------------------
public void UpdateCoverageRate(
CoverageRate coverageRate,
DTE2 dte,
ICoverageViewManager coverageViewManager)
{
this.dte = dte;
this.coverageViewManager = coverageViewManager;
this.Root = new RootCoverageTreeNode(coverageRate);
this.Filter = "";
this.DisplayCoverage = true;
if (coverageRate.ExitCode == 0)
{
this.Warning = null;
}
else
{
this.Warning = WarningMessage + coverageRate.ExitCode;
}
}
public void RootCoverageTreeNode()
{
var file = new FileCoverage("file", new List <LineCoverage>());
var module = new ModuleCoverage("module");
module.AddChild(file);
const int exitCode = 42;
var coverage = new CoverageRate("root", exitCode);
coverage.AddChild(module);
var root = new RootCoverageTreeNode(coverage);
root.EnsureLazyChildren();
var moduleNode = root.Modules.First();
moduleNode.EnsureLazyChildren();
var fileNode = moduleNode.Files.First();
Assert.AreEqual(coverage.Name, root.Text);
Assert.AreEqual(module.Name, moduleNode.Text);
Assert.AreEqual(file.Path, fileNode.Text);
}
//-----------------------------------------------------------------------
public RootCoverageTreeNode(CoverageRate coverage)
: base(coverage.Name, coverage, IconFilename, false)
{
this.coverage = coverage;
}
