public void OpenFile(string assemblyName, string qualifiedClassName, int file, int line)
{
// Note : There may be more than one file; e.g. in the case of partial classes
var sourceFiles = FCCEngine.GetSourceFiles(assemblyName, qualifiedClassName);
if (!sourceFiles.Any())
{
var message = $"Source File(s) Not Found : [{ assemblyName }]{ qualifiedClassName }";
Logger.Log(message);
MessageBox.Show(message);
return;
}
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_dte.MainWindow.Activate();
foreach (var sourceFile in sourceFiles)
{
_dte.ItemOperations.OpenFile(sourceFile, Constants.vsViewKindCode);
if (line != 0)
{
((TextSelection)_dte.ActiveDocument.Selection).GotoLine(line, false);
}
}
});
}
public void OpenFile(string htmlFilePath, int file, int line)
{
// Note : There may be more than one file; e.g. in the case of partial classes
var htmlFileName = Path.GetFileNameWithoutExtension(htmlFilePath);
var sourceFiles = FCCEngine.GetSourceFilesFromReportGeneratorHtmlFileName(htmlFileName);
if (!sourceFiles.Any())
{
var message = $"Not Found : { htmlFileName }";
Logger.Log(message);
MessageBox.Show(message);
return;
}
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_dte.MainWindow.Activate();
foreach (var sourceFile in sourceFiles)
{
_dte.ItemOperations.OpenFile(sourceFile, Constants.vsViewKindCode);
if (line != 0)
{
((TextSelection)_dte.ActiveDocument.Selection).GotoLine(line, false);
}
}
});
}
internal TestContainerDiscoverer
(
[Import(typeof(IOperationState))]
IOperationState operationState,
[Import(typeof(SVsServiceProvider))]
IServiceProvider serviceProvider
)
{
_serviceProvider = serviceProvider;
new Thread(() =>
{
try
{
Logger.Initialize(_serviceProvider);
FCCEngine.Initialize();
Initialize(_serviceProvider);
TestContainersUpdated.ToString();
operationState.StateChanged += OperationState_StateChanged;
Logger.Log($"Initialized");
}
catch (Exception exception)
{
Logger.Log($"Failed Initialization", exception);
}
}).Start();
}
public void OpenFile(string htmlFilePath, int file, int line)
{
var htmlFileName = Path.GetFileNameWithoutExtension(htmlFilePath);
var csFileName = FCCEngine.GetSourceFileNameFromReportGeneratorHtmlFileName(htmlFileName);
if (string.IsNullOrWhiteSpace(csFileName))
{
var message = $"Not Found : { htmlFileName }";
Logger.Log(message);
MessageBox.Show(message);
return;
}
ThreadHelper.JoinableTaskFactory.Run(async() =>
{
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_dte.MainWindow.Activate();
_dte.ItemOperations.OpenFile(csFileName, Constants.vsViewKindCode);
if (line != 0)
{
((TextSelection)_dte.ActiveDocument.Selection).GotoLine(line, false);
}
});
}
IEnumerable <ITagSpan <T> > ITagger <T> .GetTags(NormalizedSnapshotSpanCollection spans)
{
var result = new List <ITagSpan <T> >();
if (spans == null)
{
return(result);
}
foreach (var span in spans)
{
if (!span.Snapshot.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out ITextDocument document))
{
continue;
}
var startLineNumber = span.Start.GetContainingLine().LineNumber + 1;
var endLineNumber = span.End.GetContainingLine().LineNumber + 1;
var coverageLines = FCCEngine.GetLines(document.FilePath, startLineNumber, endLineNumber);
foreach (var coverageLine in coverageLines)
{
var tag = new GlyphTag(coverageLine);
var tagSpan = new TagSpan <GlyphTag>(span, tag);
var iTagSpan = tagSpan as ITagSpan <T>;
result.Add(iTagSpan);
}
}
return(result);
}
public void SetUp()
{
mocker = new AutoMoqer();
var mockDisposeAwareTaskRunner = mocker.GetMock <IDisposeAwareTaskRunner>();
mockDisposeAwareTaskRunner.Setup(runner => runner.RunAsync(It.IsAny <Func <Task> >())).Callback <Func <Task> >(async taskProvider => await taskProvider());
fccEngine = mocker.Create <FCCEngine>();
var mockedAppOptions = mocker.GetMock <IAppOptions>();
mockedAppOptions.Setup(x => x.RunMsCodeCoverage).Returns(RunMsCodeCoverage.No);
var mockAppOptionsProvider = mocker.GetMock <IAppOptionsProvider>();
mockAppOptionsProvider.Setup(x => x.Get()).Returns(mockedAppOptions.Object);
}
public void SetUp()
{
updatedMarginTags = false;
mocker = new AutoMoqer();
fccEngine = mocker.Create <FCCEngine>();
fccEngine.UpdateMarginTags += (UpdateMarginTagsEventArgs e) =>
{
updatedMarginTags = true;
};
fccEngine.UpdateOutputWindow += (UpdateOutputWindowEventArgs e) =>
{
htmlContent = e.HtmlContent;
};
}
private void StopCoverageProcess()
{
try
{
_reloadCoverageThread?.Abort();
}
catch
{
// ignore
}
finally
{
_reloadCoverageThread = null;
FCCEngine.ClearProcesses();
}
}
public void SetUp()
{
mocker = new AutoMoqer();
fccEngine = mocker.Create <FCCEngine>();
raisedUpdateMarginTags = false;
raisedUpdateOutputWindow = false;
tempReportGeneratedHtml = null;
htmlContent = null;
fccEngine.UpdateMarginTags += (UpdateMarginTagsEventArgs e) =>
{
raisedUpdateMarginTags = true;
};
fccEngine.UpdateOutputWindow += (UpdateOutputWindowEventArgs e) =>
{
raisedUpdateOutputWindow = true;
htmlContent = e.HtmlContent;
};
}
public void SetUp()
{
updatedMarginTags = false;
mocker = new AutoMoqer();
fccEngine = mocker.Create <FCCEngine>();
}
private void OperationState_StateChanged(object sender, OperationStateChangedEventArgs e)
{
try
{
if (e.State == TestOperationStates.TestExecutionStarting)
{
StopCoverageProcess(); // just to be sure
}
if (e.State == TestOperationStates.TestExecutionFinished)
{
var settings = AppOptions.Get();
if (!settings.Enabled)
{
FCCEngine.CoverageLines.Clear();
UpdateMarginTags?.Invoke(this, null);
UpdateOutputWindow?.Invoke(this, null);
return;
}
Logger.Log("================================== START ==================================");
var darkMode = CurrentTheme.Equals("Dark", StringComparison.OrdinalIgnoreCase);
CoverageProject[] projects = null;
try
{
var testConfiguration = new Operation(e.Operation).Configuration;
var userRunSettings = testConfiguration.UserRunSettings;
var runSettingsRetriever = new RunSettingsRetriever();
var testContainers = testConfiguration.Containers;
projects = testConfiguration.Containers.Select(container =>
{
var project = new CoverageProject();
project.ProjectName = container.ProjectName;
project.TestDllFile = container.Source;
project.Is64Bit = container.TargetPlatform.ToString().ToLower().Equals("x64");
var containerData = container.ProjectData;
project.ProjectFile = container.ProjectData.ProjectFilePath;
project.RunSettingsFile = ThreadHelper.JoinableTaskFactory.Run(() => runSettingsRetriever.GetRunSettingsFileAsync(userRunSettings, containerData));
return(project);
}).ToArray();
}catch (Exception exc)
{
throw new Exception("Error test container discoverer reflection", exc);
}
_reloadCoverageThread = new Thread(() =>
{
try
{
// compute coverage
FCCEngine.ReloadCoverage(projects, darkMode);
// update margins
{
UpdateMarginTagsEventArgs updateMarginTagsEventArgs = null;
try
{
updateMarginTagsEventArgs = new UpdateMarginTagsEventArgs
{
};
}
catch
{
// ignore
}
finally
{
UpdateMarginTags?.Invoke(this, updateMarginTagsEventArgs);
}
}
// update output window
{
UpdateOutputWindowEventArgs updateOutputWindowEventArgs = null;
try
{
updateOutputWindowEventArgs = new UpdateOutputWindowEventArgs
{
HtmlContent = File.ReadAllText(FCCEngine.HtmlFilePath)
};
}
catch
{
// ignore
}
finally
{
UpdateOutputWindow?.Invoke(this, updateOutputWindowEventArgs);
}
}
// log
Logger.Log("================================== DONE ===================================");
}
catch (Exception exception)
{
if (!(exception is ThreadAbortException) && _reloadCoverageThread != null)
{
Logger.Log("Error", exception);
Logger.Log("================================== ERROR ==================================");
}
}
});
_reloadCoverageThread.Start();
}
}
catch (Exception exception)
{
Logger.Log("Error processing unit test events", exception);
}
}
private void OperationState_StateChanged(object sender, OperationStateChangedEventArgs e)
{
try
{
if (e.State == TestOperationStates.TestExecutionCanceling)
{
FCCEngine.StopCoverage();
}
if (e.State == TestOperationStates.TestExecutionStarting)
{
FCCEngine.StopCoverage();
FCCEngine.TryReloadCoverage(settings =>
{
if (!settings.RunInParallel)
{
return(null);
}
return(GetCoverageProjects(new Operation(e.Operation).Configuration));
});
}
if (e.State == TestOperationStates.TestExecutionFinished)
{
FCCEngine.TryReloadCoverage(settings =>
{
if (settings.RunInParallel)
{
return(null);
}
var operation = new Operation(e.Operation);
if (!settings.RunWhenTestsFail && operation.Response.FailedTests > 0)
{
Logger.Log($"Skipping coverage due to failed tests. Option {nameof(AppOptions.RunWhenTestsFail)} is false");
return(null);
}
var totalTests = operation.TotalTests;
var runWhenTestsExceed = settings.RunWhenTestsExceed;
if (totalTests > 0) // in case this changes to not reporting total tests
{
if (totalTests <= runWhenTestsExceed)
{
Logger.Log($"Skipping coverage as total tests ({totalTests}) <= {nameof(AppOptions.RunWhenTestsExceed)} ({runWhenTestsExceed})");
return(null);
}
}
return(GetCoverageProjects(operation.Configuration));
});
}
}
catch (PropertyDoesNotExistException propertyDoesNotExistException)
{
Logger.Log("Error test container discoverer reflection");
throw new Exception(propertyDoesNotExistException.Message);
}
catch (Exception exception)
{
Logger.Log("Error processing unit test events", exception);
}
}
private void OperationState_StateChanged(object sender, OperationStateChangedEventArgs e)
{
try
{
if (e.State == TestOperationStates.TestExecutionStarting)
{
try
{
_reloadCoverageThread?.Abort();
}
catch
{
// ignore
}
finally
{
_reloadCoverageThread = null;
FCCEngine.ClearProcesses();
}
}
if (e.State == TestOperationStates.TestExecutionFinished)
{
var settings = AppOptions.Get();
if (!settings.Enabled)
{
FCCEngine.CoverageLines.Clear();
UpdateMarginTags?.Invoke(this, null);
UpdateOutputWindow?.Invoke(this, null);
return;
}
Logger.Log("================================== START ==================================");
var operationType = e.Operation.GetType();
var darkMode = CurrentTheme.Equals("Dark", StringComparison.OrdinalIgnoreCase);
var testConfiguration = (operationType.GetProperty("Configuration") ?? operationType.GetProperty("Configuration", BindingFlags.Instance | BindingFlags.NonPublic)).GetValue(e.Operation);
var testContainers = ((IEnumerable <object>)testConfiguration.GetType().GetProperty("Containers").GetValue(testConfiguration)).ToArray();
var projects = new List <CoverageProject>();
foreach (var container in testContainers)
{
var project = new CoverageProject();
var containerType = container.GetType();
var containerData = containerType.GetProperty("ProjectData").GetValue(container);
var containerDataType = containerData.GetType();
project.ProjectGuid = containerType.GetProperty("ProjectGuid").GetValue(container).ToString();
project.ProjectName = containerType.GetProperty("ProjectName").GetValue(container).ToString();
project.TestDllFileInOutputFolder = containerType.GetProperty("Source").GetValue(container).ToString();
project.TestDllCompilationMode = AssemblyUtil.GetCompilationMode(project.TestDllFileInOutputFolder);
project.ProjectFile = containerDataType.GetProperty("ProjectFilePath", BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic).GetValue(containerData).ToString();
var defaultOutputFolder = Path.GetDirectoryName(containerDataType.GetProperty("DefaultOutputPath", BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic).GetValue(containerData).ToString());
project.WorkFolder = Path.Combine(Path.GetDirectoryName(defaultOutputFolder), "fine-code-coverage");
projects.Add(project);
}
_reloadCoverageThread = new Thread(() =>
{
try
{
// compute coverage
FCCEngine.ReloadCoverage(projects.ToArray(), darkMode);
// update margins
{
UpdateMarginTagsEventArgs updateMarginTagsEventArgs = null;
try
{
updateMarginTagsEventArgs = new UpdateMarginTagsEventArgs
{
};
}
catch
{
// ignore
}
finally
{
UpdateMarginTags?.Invoke(this, updateMarginTagsEventArgs);
}
}
// update output window
{
UpdateOutputWindowEventArgs updateOutputWindowEventArgs = null;
try
{
updateOutputWindowEventArgs = new UpdateOutputWindowEventArgs
{
HtmlContent = File.ReadAllText(FCCEngine.HtmlFilePath)
};
}
catch
{
// ignore
}
finally
{
UpdateOutputWindow?.Invoke(this, updateOutputWindowEventArgs);
}
}
// log
Logger.Log("================================== DONE ===================================");
}
catch (Exception exception)
{
if (!(exception is ThreadAbortException) && _reloadCoverageThread != null)
{
Logger.Log("Error", exception);
Logger.Log("================================== ERROR ==================================");
}
}
});
_reloadCoverageThread.Start();
}
}
catch (Exception exception)
{
Logger.Log("Error processing unit test events", exception);
}
}
