private void DoWithTestRunner(Action <ITestRunner> action, IProgressMonitor progressMonitor,
double initializationAndDisposalWorkUnits, IEnumerable <string> testRunnerExtensions)
{
if (testRunnerFactory == null)
{
throw new InvalidOperationException("A test runner factory must be set first.");
}
var testRunner = testRunnerFactory.CreateTestRunner();
try
{
var testRunnerOptions = new TestRunnerOptions();
var logger = RuntimeAccessor.Logger;
RegisterTestRunnerExtensions(testRunnerExtensions, testRunner);
var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(initializationAndDisposalWorkUnits / 2);
testRunner.Initialize(testRunnerOptions, logger, subProgressMonitor);
WireUpTestRunnerEvents(testRunner);
action(testRunner);
}
finally
{
var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(initializationAndDisposalWorkUnits / 2);
testRunner.Dispose(subProgressMonitor);
}
}
private void OpenProject(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
{
projectController.OpenProject(subProgressMonitor, ProjectLocation);
}
}
public void Execute(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Creating new project", 100))
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(20))
{
projectController.NewProject(subProgressMonitor);
}
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(80))
{
var command = commandFactory.CreateLoadPackageCommand();
command.Execute(subProgressMonitor);
}
}
}
public void Execute(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Removing all files.", 100))
{
// remove all files from test package
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
projectController.RemoveAllFiles();
// reload
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var loadPackageCommand = new LoadPackageCommand(testController, projectController);
loadPackageCommand.Execute(subProgressMonitor);
}
}
}
private void ResetTestStatus(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(5))
{
eventAggregator.Send(this, new TestsReset());
}
}
private void ResetTestStatus(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(5))
{
eventAggregator.Send(this, new TestsReset());
}
}
private void SaveProject(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
projectController.Save(ProjectLocation, subProgressMonitor);
}
}
private void SetTestPackage(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(10))
{
testController.SetTestPackage(projectController.TestPackage);
}
}
private void ExploreTests(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90))
{
testController.Explore(subProgressMonitor, projectController.TestRunnerExtensionSpecifications);
}
}
private void SetTestPackage(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(10))
{
testController.SetTestPackage(projectController.TestPackage);
}
}
public string SaveReportAs(Report report, string fileName, string format, IProgressMonitor progressMonitor)
{
var file = string.Empty;
using (progressMonitor.BeginTask("Generating report", 100))
{
var folderName = Path.GetDirectoryName(fileName);
var reportContainer = new FileSystemReportContainer(folderName,
Path.GetFileNameWithoutExtension(fileName));
var reportWriter = reportManager.CreateReportWriter(report, reportContainer);
if (progressMonitor.IsCanceled)
throw new OperationCanceledException();
// Delete the report if it already exists
reportContainer.DeleteReport();
if (progressMonitor.IsCanceled)
throw new OperationCanceledException();
progressMonitor.Worked(10);
// Format the report
var reportFormatterOptions = new ReportFormatterOptions();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90))
reportManager.Format(reportWriter, format, reportFormatterOptions, subProgressMonitor);
if (progressMonitor.IsCanceled)
throw new OperationCanceledException();
if (reportWriter.ReportDocumentPaths.Count > 0)
file = Path.Combine(folderName, reportWriter.ReportDocumentPaths[0]);
}
return file;
}
/// <summary>
/// Loads plugins by recursively searching the plugin paths for *.plugin files.
/// </summary>
/// <param name="pluginCallback">A function that receives plugin metadata as it
/// becomes available, not null.</param>
/// <param name="progressMonitor"></param>
protected virtual void LoadPlugins(PluginCallback pluginCallback, IProgressMonitor progressMonitor)
{
if (pluginPaths.Count == 0)
{
return;
}
var uniquePluginFilePaths = new HashSet <string>();
using (progressMonitor.BeginTask("Loading plugins", pluginPaths.Count))
{
foreach (var pluginPath in pluginPaths)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
{
var pluginDirectory = new DirectoryInfo(pluginPath);
if (pluginDirectory.Exists)
{
LoadPluginsFromDirectory(pluginDirectory, uniquePluginFilePaths, pluginCallback, subProgressMonitor);
}
else
{
var pluginFile = new FileInfo(pluginPath);
if (pluginFile.Exists)
{
LoadPluginsFromFile(pluginFile, uniquePluginFilePaths, pluginCallback, subProgressMonitor);
}
}
}
}
}
}
private void ExploreTests(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90))
{
testController.Explore(subProgressMonitor, projectController.TestRunnerExtensionSpecifications);
}
}
/// <inheritdoc />
public override void ApplyPendingSettingsChanges(IElevationContext elevationContext, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Saving preferences.", 1))
{
var preferencePanes = new List <PreferencePane>(GetPreferencePanes());
if (preferencePanes.Count == 0)
{
return;
}
double workPerPreferencePane = 1.0 / preferencePanes.Count;
foreach (PreferencePane preferencePane in preferencePanes)
{
if (progressMonitor.IsCanceled)
{
return;
}
if (preferencePane.PendingSettingsChanges)
{
preferencePane.ApplyPendingSettingsChanges(
preferencePane.RequiresElevation ? elevationContext : null,
progressMonitor.CreateSubProgressMonitor(workPerPreferencePane));
}
else
{
progressMonitor.Worked(workPerPreferencePane);
}
}
}
}
private void SaveUserOptions(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(40))
{
projectUserOptionsController.SaveUserOptions(ProjectLocation, subProgressMonitor);
}
}
public void Execute(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Removing all files.", 100))
{
// remove all files from test package
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
projectController.RemoveAllFiles();
// reload
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var loadPackageCommand = new LoadPackageCommand(testController, projectController);
loadPackageCommand.Execute(subProgressMonitor);
}
}
}
private static bool InstallOrUninstallWithElevationContext(IEnumerable<ComponentHandle<IInstaller, InstallerTraits>> installerHandles,
IElevationContext elevationContext, IProgressMonitor progressMonitor,
InstallerOperation operation)
{
foreach (var installerHandle in installerHandles)
{
if (progressMonitor.IsCanceled)
return false;
IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1);
if (elevationContext != null && installerHandle.GetTraits().RequiresElevation)
{
elevationContext.Execute(InstallerElevatedCommand.ElevatedCommandId,
new InstallerElevatedCommand.Arguments(installerHandle.Id, operation),
subProgressMonitor);
}
else
{
IInstaller installer = installerHandle.GetComponent();
if (operation == InstallerOperation.Install)
installer.Install(progressMonitor.CreateSubProgressMonitor(1));
else
installer.Uninstall(progressMonitor.CreateSubProgressMonitor(1));
}
}
return true;
}
private void OpenProject(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
{
projectController.OpenProject(subProgressMonitor, ProjectLocation);
}
}
private void ExploreOrRun(ITestIsolationContext testIsolationContext, TestPackage testPackage, TestExplorationOptions testExplorationOptions,
TestExecutionOptions testExecutionOptions, IMessageSink messageSink, IProgressMonitor progressMonitor, string taskName)
{
using (progressMonitor.BeginTask(taskName, 1))
{
if (progressMonitor.IsCanceled)
{
return;
}
FileInfo testDriverScriptFile = GetTestDriverScriptFile(testPackage);
if (testDriverScriptFile == null)
{
return;
}
HostSetup hostSetup = CreateHostSetup(testPackage);
ScriptRuntimeSetup scriptRuntimeSetup = CreateScriptRuntimeSetup(testPackage);
string testDriverScriptPath = testDriverScriptFile.FullName;
var remoteMessageSink = new RemoteMessageSink(messageSink);
var remoteLogger = new RemoteLogger(logger);
using (var remoteProgressMonitor = new RemoteProgressMonitor(progressMonitor.CreateSubProgressMonitor(1)))
{
testIsolationContext.RunIsolatedTask <ExploreOrRunTask>(hostSetup,
(statusMessage) => progressMonitor.SetStatus(statusMessage),
new object[] { testPackage, scriptRuntimeSetup, testDriverScriptPath, testExplorationOptions, testExecutionOptions,
remoteMessageSink, remoteProgressMonitor, remoteLogger });
}
}
}
private void SaveUserOptions(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(40))
{
projectUserOptionsController.SaveUserOptions(ProjectLocation, subProgressMonitor);
}
}
private void SaveProject(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
projectController.Save(ProjectLocation, subProgressMonitor);
}
}
private void RunTests(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var runTestsCommand = commandFactory.CreateRunTestsCommand(false);
runTestsCommand.Execute(subProgressMonitor);
}
}
private void LoadPackage(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(85))
{
var loadPackageCommand = commandFactory.CreateLoadPackageCommand();
loadPackageCommand.Execute(subProgressMonitor);
}
}
private void SaveLastRunFilter(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(5))
{
var filterSet = filterService.GenerateFilterSetFromSelectedTests();
projectController.SaveFilterSet("LastRun", filterSet);
}
}
private void LoadPackage(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(85))
{
var loadPackageCommand = commandFactory.CreateLoadPackageCommand();
loadPackageCommand.Execute(subProgressMonitor);
}
}
private void RunTests(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var runTestsCommand = commandFactory.CreateRunTestsCommand(false);
runTestsCommand.Execute(subProgressMonitor);
}
}
private void SaveCurrentTestFilter(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
var command = commandFactory.CreateSaveFilterCommand("AutoSave");
command.Execute(subProgressMonitor);
}
}
private void SaveCurrentTestFilter(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
var command = commandFactory.CreateSaveFilterCommand("AutoSave");
command.Execute(subProgressMonitor);
}
}
private void SaveLastRunFilter(IProgressMonitor progressMonitor)
{
using (progressMonitor.CreateSubProgressMonitor(5))
{
var filterSet = filterService.GenerateFilterSetFromSelectedTests();
projectController.SaveFilterSet("LastRun", filterSet);
}
}
private void RestoreTestFilter(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
{
var restoreFilterCommand = commandFactory.CreateRestoreFilterCommand("AutoSave");
restoreFilterCommand.Execute(subProgressMonitor);
}
}
private void LoadPackage(IProgressMonitor progressMonitor)
{
var workUnits = optionsController.RunTestsAfterReload ? 35 : 85;
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(workUnits))
{
var command = commandFactory.CreateLoadPackageCommand();
command.Execute(subProgressMonitor);
}
}
private static void ApplyCatalogToRegistry(IProgressMonitor progressMonitor,
IPluginCatalog pluginCatalog, IRegistry registry)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
{
subProgressMonitor.BeginTask(Resources.UpdatePluginFolderCommand_Applying_catalog_to_registry, 100);
pluginCatalog.ApplyTo(registry);
}
}
private static void ApplyCatalogToRegistry(IProgressMonitor progressMonitor,
IPluginCatalog pluginCatalog, IRegistry registry)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
{
subProgressMonitor.BeginTask(Resources.UpdatePluginFolderCommand_Applying_catalog_to_registry, 100);
pluginCatalog.ApplyTo(registry);
}
}
public void Execute(IProgressMonitor progressMonitor)
{
if (Files == null || Files.Count == 0)
throw new Exception("No files to add");
using (progressMonitor.BeginTask(Resources.AddingFiles, 100))
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
projectController.AddFiles(subProgressMonitor, Files);
}
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90))
{
var loadPackageCommand = commandFactory.CreateLoadPackageCommand();
loadPackageCommand.Execute(subProgressMonitor);
}
}
}
public string ConvertSavedReport(string fileName, string format,
IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Converting saved report", 100))
{
var reportContainer = new FileSystemReportContainer(Path.GetDirectoryName(fileName),
Path.GetFileNameWithoutExtension(fileName));
var reportReader = reportManager.CreateReportReader(reportContainer);
Report report;
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(20))
report = reportReader.LoadReport(true, subProgressMonitor);
var tempFilePath = SpecialPathPolicy.For <ReportService>().CreateTempDirectoryWithUniqueName().FullName;
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(80))
return(SaveReportAs(report, tempFilePath, format, subProgressMonitor));
}
}
public void ResetTestStatus(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Resetting test status.", 5))
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(4))
testTreeModel.ResetTestStatus(subProgressMonitor);
eventAggregator.Send(this, new TestsReset());
}
}
private static PluginCatalog PopulateCatalog(IProgressMonitor progressMonitor,
IPluginLoader pluginLoader)
{
var pluginCatalog = new PluginCatalog();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
pluginLoader.PopulateCatalog(pluginCatalog, subProgressMonitor);
return(pluginCatalog);
}
private void LoadPackage(IProgressMonitor progressMonitor)
{
var workUnits = optionsController.RunTestsAfterReload ? 35 : 85;
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(workUnits))
{
var command = commandFactory.CreateLoadPackageCommand();
command.Execute(subProgressMonitor);
}
}
private void RunAll(IProgressMonitor progressMonitor, ITestCommand rootTestCommand)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
{
using (subProgressMonitor.BeginTask("Running the tests.", rootTestCommand.TestCount))
{
RunTest(rootTestCommand, null, subProgressMonitor);
}
}
}
private void RunAll(IProgressMonitor progressMonitor, ITestCommand rootTestCommand)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
{
using (subProgressMonitor.BeginTask("Running the tests.", rootTestCommand.TestCount))
{
RunTest(rootTestCommand, null, subProgressMonitor);
}
}
}
public void Execute(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Removing file.", 100))
{
if (string.IsNullOrEmpty(FileName))
return;
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
projectController.RemoveFile(FileName);
}
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var loadPackageCommand = new LoadPackageCommand(testController, projectController);
loadPackageCommand.Execute(subProgressMonitor);
}
}
}
private static PluginCatalog PopulateCatalog(IProgressMonitor progressMonitor,
IPluginLoader pluginLoader)
{
var pluginCatalog = new PluginCatalog();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(45))
pluginLoader.PopulateCatalog(pluginCatalog, subProgressMonitor);
return pluginCatalog;
}
/// <inheritdoc />
public void PopulateCatalog(IPluginCatalog catalog, IProgressMonitor progressMonitor)
{
if (catalog == null)
{
throw new ArgumentNullException("catalog");
}
using (progressMonitor.BeginTask("Populating catalog", 100))
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
LoadPlugins((p, bd, pfp) => catalog.AddPlugin(p, bd), subProgressMonitor);
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
if (pluginXmls.Count > 0)
{
ReadPluginsFromXml(catalog, subProgressMonitor);
}
}
}
private TestResult RunTest(ITestCommand testCommand, TestStep parentTestStep,
TestExecutionOptions options, IProgressMonitor progressMonitor)
{
// NOTE: This method has been optimized to minimize the total stack depth of the action
// by inlining blocks on the critical path that had previously been factored out.
using (TestController testController = testControllerProvider(testCommand.Test))
{
if (testController != null)
{
try
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(testCommand.TestCount))
{
// Calling RunImpl directly instead of Run to minimize stack depth
// because we already know the arguments are valid.
return(testController.RunImpl(testCommand, parentTestStep, options, subProgressMonitor));
}
}
catch (Exception ex)
{
ITestContext context = testCommand.StartPrimaryChildStep(parentTestStep);
context.LogWriter.Failures.WriteException(ex, "Fatal Exception in test controller");
return(context.FinishStep(TestOutcome.Error, null));
}
}
}
// Enter the scope of the test and recurse until we find a controller.
progressMonitor.SetStatus(testCommand.Test.FullName);
ITestContext testContext = testCommand.StartPrimaryChildStep(parentTestStep);
TestOutcome outcome = TestOutcome.Passed;
foreach (ITestCommand monitor in testCommand.Children)
{
if (progressMonitor.IsCanceled)
{
break;
}
TestResult childResult = RunTest(monitor, testContext.TestStep, options, progressMonitor);
outcome = outcome.CombineWith(childResult.Outcome).Generalize();
}
if (progressMonitor.IsCanceled)
{
outcome = TestOutcome.Canceled;
}
TestResult result = testContext.FinishStep(outcome, null);
progressMonitor.Worked(1);
return(result);
}
public void Explore(IProgressMonitor progressMonitor,
IEnumerable <string> testRunnerExtensions)
{
using (progressMonitor.BeginTask("Exploring the tests", 100))
{
eventAggregator.Send(this, new ExploreStarted());
DoWithTestRunner(testRunner =>
{
var testExplorationOptions = new TestExplorationOptions();
testRunner.Explore(testPackage, testExplorationOptions,
progressMonitor.CreateSubProgressMonitor(80));
RefreshTestTree(progressMonitor.CreateSubProgressMonitor(10));
}, progressMonitor, 10, testRunnerExtensions);
eventAggregator.Send(this, new ExploreFinished());
}
}
private void SaveCurrentState(IProgressMonitor progressMonitor)
{
eventAggregator.Send(this, new Reloading());
eventAggregator.Send(this, new UserOptionsLoaded());
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
var command = commandFactory.CreateSaveFilterCommand("AutoSave");
command.Execute(subProgressMonitor);
}
}
private void SaveCurrentState(IProgressMonitor progressMonitor)
{
eventAggregator.Send(this, new Reloading());
eventAggregator.Send(this, new UserOptionsLoaded());
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
var command = commandFactory.CreateSaveFilterCommand("AutoSave");
command.Execute(subProgressMonitor);
}
}
private PluginLoader SetupPluginLoader(IProgressMonitor progressMonitor)
{
var pluginLoader = new PluginLoader();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
subProgressMonitor.BeginTask(Resources.UpdatePluginFolderCommand_Adding_plugin_path, 100);
pluginLoader.AddPluginPath(PluginFolder);
}
return pluginLoader;
}
public void Execute(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Removing file.", 100))
{
if (string.IsNullOrEmpty(FileName))
{
return;
}
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
projectController.RemoveFile(FileName);
}
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(50))
{
var loadPackageCommand = new LoadPackageCommand(testController, projectController);
loadPackageCommand.Execute(subProgressMonitor);
}
}
}
private PluginLoader SetupPluginLoader(IProgressMonitor progressMonitor)
{
var pluginLoader = new PluginLoader();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(10))
{
subProgressMonitor.BeginTask(Resources.UpdatePluginFolderCommand_Adding_plugin_path, 100);
pluginLoader.AddPluginPath(PluginFolder);
}
return(pluginLoader);
}
private TestResult RunTest(ITestCommand testCommand, TestStep parentTestStep,
TestExecutionOptions options, IProgressMonitor progressMonitor)
{
// NOTE: This method has been optimized to minimize the total stack depth of the action
// by inlining blocks on the critical path that had previously been factored out.
using (TestController testController = testControllerProvider(testCommand.Test))
{
if (testController != null)
{
try
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(testCommand.TestCount))
{
// Calling RunImpl directly instead of Run to minimize stack depth
// because we already know the arguments are valid.
return testController.RunImpl(testCommand, parentTestStep, options, subProgressMonitor);
}
}
catch (Exception ex)
{
ITestContext context = testCommand.StartPrimaryChildStep(parentTestStep);
context.LogWriter.Failures.WriteException(ex, "Fatal Exception in test controller");
return context.FinishStep(TestOutcome.Error, null);
}
}
}
// Enter the scope of the test and recurse until we find a controller.
progressMonitor.SetStatus(testCommand.Test.FullName);
ITestContext testContext = testCommand.StartPrimaryChildStep(parentTestStep);
TestOutcome outcome = TestOutcome.Passed;
foreach (ITestCommand monitor in testCommand.Children)
{
if (progressMonitor.IsCanceled)
break;
TestResult childResult = RunTest(monitor, testContext.TestStep, options, progressMonitor);
outcome = outcome.CombineWith(childResult.Outcome).Generalize();
}
if (progressMonitor.IsCanceled)
outcome = TestOutcome.Canceled;
TestResult result = testContext.FinishStep(outcome, null);
progressMonitor.Worked(1);
return result;
}
public void Execute(IProgressMonitor progressMonitor)
{
if (files.Count == 0)
return;
using (progressMonitor.BeginTask("Copying files", files.Count))
{
foreach (var file in files)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
CopyFile(subProgressMonitor, file);
}
}
}
public void Execute(IProgressMonitor progressMonitor)
{
if (sourcePlugins.Count == 0)
return;
using (progressMonitor.BeginTask("Copying plugins", sourcePlugins.Count))
{
foreach (var plugin in sourcePlugins)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
SafeCopy(plugin, subProgressMonitor);
}
}
}
public void Execute(IProgressMonitor progressMonitor)
{
if (string.IsNullOrEmpty(FilterName))
throw new ArgumentException("Filter name cannot be null or empty");
using (progressMonitor.BeginTask("Saving filter", 2))
{
var filterSet = filterService.GenerateFilterSetFromSelectedTests();
if (progressMonitor.IsCanceled)
throw new OperationCanceledException();
using (progressMonitor.CreateSubProgressMonitor(50))
projectController.SaveFilterSet(FilterName, filterSet);
}
}
public override void ApplyPendingSettingsChanges(IElevationContext elevationContext, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Saving TestDriven.Net preferences.", 2))
{
base.ApplyPendingSettingsChanges(elevationContext, progressMonitor);
foreach (DataGridViewRow row in frameworkGridView.Rows)
{
var installationMode = InstallationModeFromString((string)row.Cells[1].Value);
var frameworkId = (string)row.Tag;
PreferenceManager.SetInstallationModeForFramework(frameworkId, installationMode);
}
progressMonitor.Worked(1);
InstallerManager.Install(new[] {TDNetRunnerInstaller.InstallerId}, elevationContext, progressMonitor.CreateSubProgressMonitor(1));
}
}
private void GenerateReport(IProgressMonitor progressMonitor)
{
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
{
if (!optionsController.GenerateReportAfterTestRun)
return;
var reportOptions = new ReportOptions(projectController.ReportDirectory,
projectController.ReportNameFormat);
var cmd = new GenerateReportCommand(testController, reportController)
{
ReportOptions = reportOptions
};
cmd.Execute(subProgressMonitor);
}
}
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions formatterOptions, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Formatting report.", 10))
{
using (MultipartMimeReportContainer archiveContainer = new MultipartMimeReportContainer(reportWriter.ReportContainer))
{
string archivePath = archiveContainer.ReportName + ".mht";
reportWriter.AddReportDocumentPath(archivePath);
archiveContainer.OpenArchive(archivePath);
progressMonitor.Worked(0.5);
DefaultReportWriter archiveWriter = new DefaultReportWriter(reportWriter.Report, archiveContainer);
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(9))
htmlReportFormatter.Format(archiveWriter, formatterOptions, subProgressMonitor);
archiveContainer.CloseArchive();
progressMonitor.Worked(0.5);
}
}
}
