/// <inheritdoc />
sealed protected override void ExploreAssembly(Assembly assembly, TestExplorationOptions testExplorationOptions, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask(string.Format("Exploring {0} tests.", FrameworkName), 5))
{
using (TestHarness testHarness = CreateTestHarness())
{
IDisposable appDomainState = null;
try
{
progressMonitor.SetStatus("Setting up the test harness.");
appDomainState = testHarness.SetUpAppDomain();
progressMonitor.Worked(1);
progressMonitor.SetStatus("Building the test model.");
GenerateTestModel(assembly, messageSink);
progressMonitor.Worked(3);
}
finally
{
progressMonitor.SetStatus("Tearing down the test harness.");
if (appDomainState != null)
{
appDomainState.Dispose();
}
progressMonitor.Worked(1);
}
}
}
}
void ITestListener.OnAssemblyFinished(object sender, AssemblyEventArgs args)
{
ITestCommand testCommand;
string testName = args.AssemblyFullName.Split(',')[0];
if (!testCommandsByName.TryGetValue(testName, out testCommand))
{
return;
}
if (testContextStack.Count == 0)
{
return;
}
ITestContext testContext = testContextStack.Pop();
while (testContext.TestStep.Test != testCommand.Test)
{
testContext.FinishStep(GetFixtureOutcome(fixtureFailureCount, fixtureErrorCount), null);
testContext = testContextStack.Pop();
progressMonitor.Worked(1);
}
topResult = testContext.FinishStep(CalculateOutcome(assemblyFailureCount, assemblyErrorCount), null);
progressMonitor.Worked(1);
}
public override void Install(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Installing TestDriven.Net Runner", testFrameworkManager.TestFrameworkHandles.Count + 2))
{
// Remove old registrations.
RemoveExistingRegistryKeys(progressMonitor);
progressMonitor.Worked(1);
// Register Icarus
string icarusPath = FindIcarusPath();
if (icarusPath != null)
InstallRegistryKeysForIcarus(icarusPath, progressMonitor);
progressMonitor.Worked(1);
// Register frameworks
foreach (ComponentHandle<ITestFramework, TestFrameworkTraits> testFrameworkHandle in testFrameworkManager.TestFrameworkHandles)
{
TestFrameworkTraits testFrameworkTraits = testFrameworkHandle.GetTraits();
TDNetRunnerInstallationMode installationMode = preferenceManager.GetInstallationModeForFramework(testFrameworkHandle.Id);
if (installationMode != TDNetRunnerInstallationMode.Disabled)
{
int priority = installationMode == TDNetRunnerInstallationMode.Default ? 25 : 5;
foreach (AssemblySignature frameworkAssembly in testFrameworkTraits.FrameworkAssemblies)
{
InstallRegistryKeysForFramework(testFrameworkTraits.Name, frameworkAssembly, priority,
progressMonitor);
}
}
progressMonitor.Worked(1);
}
}
}
public void Save(string projectLocation, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Saving project", 100))
{
eventAggregator.Send(this, new SavingProject());
if (string.IsNullOrEmpty(projectLocation))
{
projectLocation = projectTreeModel.FileName;
}
var dir = Path.GetDirectoryName(projectLocation);
if (fileSystem.DirectoryExists(dir) == false)
{
fileSystem.CreateDirectory(dir);
}
progressMonitor.Worked(10);
testProjectManager.SaveProject(projectTreeModel.TestProject, new FileInfo(projectLocation));
progressMonitor.Worked(50);
eventAggregator.Send(this, new ProjectSaved(projectLocation));
}
}
/// <inheritdoc />
protected override void Execute(UnmanagedTestRepository repository, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Running " + repository.FileName, 4))
{
progressMonitor.SetStatus("Building the test model.");
BuildTestModel(repository, progressMonitor);
progressMonitor.Worked(1);
progressMonitor.SetStatus("Running the tests.");
RunTests(repository, progressMonitor);
progressMonitor.Worked(3);
}
}
/// <inheritdoc />
protected override void Execute(UnmanagedTestRepository repository, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Running " + repository.FileName, 4))
{
progressMonitor.SetStatus("Building the test model.");
BuildTestModel(repository, progressMonitor);
progressMonitor.Worked(1);
progressMonitor.SetStatus("Running the tests.");
RunTests(repository, progressMonitor);
progressMonitor.Worked(3);
}
}
private void RunTestModel(TestModel testModel, IMessageSink messageSink, IProgressMonitor progressMonitor, double totalWork)
{
double workUnitsPerStep = totalWork / (1 + testModel.RootTest.Children.Count);
TestStep rootTestStep = new TestStep(testModel.RootTest, null);
messageSink.Publish(new TestStepStartedMessage()
{
Step = new TestStepData(rootTestStep)
});
foreach (Test test in testModel.RootTest.Children)
{
if (progressMonitor.IsCanceled)
{
return;
}
TestStep testStep = new TestStep(test, rootTestStep);
messageSink.Publish(new TestStepStartedMessage()
{
Step = new TestStepData(testStep)
});
messageSink.Publish(new TestStepLogStreamWriteMessage()
{
StepId = testStep.Id,
StreamName = MarkupStreamNames.Warnings,
Text = FallbackExplanation
});
messageSink.Publish(new TestStepFinishedMessage()
{
StepId = testStep.Id,
Result = new TestResult(TestOutcome.Ignored)
});
progressMonitor.Worked(workUnitsPerStep);
}
messageSink.Publish(new TestStepFinishedMessage()
{
StepId = rootTestStep.Id,
Result = new TestResult(TestOutcome.Skipped)
});
progressMonitor.Worked(workUnitsPerStep);
}
private bool ApplySettingsChanges(IElevationContext elevationContext, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Applying changes.", 1))
{
var tabs = new List <ControlPanelTab>(GetControlPanelTabs());
if (tabs.Count == 0)
{
return(true);
}
double workPerTab = 1.0 / tabs.Count;
foreach (ControlPanelTab tab in tabs)
{
if (progressMonitor.IsCanceled)
{
return(false);
}
if (tab.PendingSettingsChanges)
{
tab.ApplyPendingSettingsChanges(tab.RequiresElevation ? elevationContext : null, progressMonitor.CreateSubProgressMonitor(workPerTab));
}
else
{
progressMonitor.Worked(workPerTab);
}
}
}
return(true);
}
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;
}
private TestModel PublishTestModelFromFiles(IEnumerable <FileInfo> files, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
TestModel testModel = new TestModel();
foreach (FileInfo file in files)
{
if (progressMonitor.IsCanceled)
{
return(null);
}
messageSink.Publish(new AnnotationDiscoveredMessage()
{
Annotation = new AnnotationData(AnnotationType.Warning,
new CodeLocation(file.FullName, 0, 0),
CodeReference.Unknown,
string.Format("File '{0}' is not supported by any installed test framework. It will be ignored.", file.Name), null)
});
Test fileTest = CreateTest(file.Name, null);
fileTest.Metadata.Add(MetadataKeys.File, file.FullName);
testModel.RootTest.AddChild(fileTest);
progressMonitor.Worked(1);
}
TestModelSerializer.PublishTestModel(testModel, messageSink);
return(testModel);
}
/// <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);
}
}
}
}
public void NewProject(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Creating new project", 100))
{
var projectLocation = Paths.DefaultProject;
var testProject = testProjectManager.NewProject(projectLocation);
progressMonitor.Worked(50);
LoadProject(testProject, projectLocation);
}
}
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);
}
private void ExploreOrRunAssembly(ITestIsolationContext testIsolationContext, TestPackage testPackage, TestExplorationOptions testExplorationOptions,
TestExecutionOptions testExecutionOptions, RemoteMessageSink remoteMessageSink, IProgressMonitor progressMonitor, string taskName,
FileInfo file)
{
using (progressMonitor.BeginTask(taskName, 100))
{
if (progressMonitor.IsCanceled)
{
return;
}
string assemblyPath = file.FullName;
progressMonitor.SetStatus("Getting test assembly metadata.");
AssemblyMetadata assemblyMetadata = AssemblyUtils.GetAssemblyMetadata(assemblyPath, AssemblyMetadataFields.RuntimeVersion);
progressMonitor.Worked(2);
if (progressMonitor.IsCanceled)
{
return;
}
if (assemblyMetadata != null)
{
Type driverType = GetType();
object[] driverArguments = GetRemoteTestDriverArguments();
HostSetup hostSetup = CreateHostSetup(testPackage, assemblyPath, assemblyMetadata);
using (var remoteProgressMonitor = new RemoteProgressMonitor(
progressMonitor.CreateSubProgressMonitor(97)))
{
testIsolationContext.RunIsolatedTask <ExploreOrRunTask>(hostSetup,
(statusMessage) => progressMonitor.SetStatus(statusMessage),
new object[] { driverType, driverArguments, assemblyPath, testExplorationOptions, testExecutionOptions, remoteMessageSink, remoteProgressMonitor });
}
// Record one final work unit after the isolated task has been fully cleaned up.
progressMonitor.SetStatus("");
progressMonitor.Worked(1);
}
}
}
private TestResult RunTestStep(ITestCommand testCommand, TestInfoData testStepInfo, TestStep parentTestStep, IProgressMonitor progressMonitor)
{
ITestContext testContext = testCommand.StartPrimaryChildStep(parentTestStep);
TestStepResult testStepResult = repository.RunTest(testStepInfo);
reporter.Run(testContext, testStepInfo, testStepResult);
WriteToTestLog(testContext, testStepResult);
testContext.AddAssertCount(testStepResult.AssertCount);
progressMonitor.Worked(1);
return(testContext.FinishStep(testStepResult.TestOutcome, testStepResult.Duration));
}
/// <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);
}
}
}
/// <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);
}
}
}
public TestTreeNode BuildTree(IProgressMonitor progressMonitor, TestModelData testModelData,
TreeBuilderOptions options)
{
var root = new TestDataNode(testModelData.RootTest);
progressMonitor.Worked(1);
PopulateNamespaceTree(progressMonitor, testModelData.RootTest.Children,
root, options);
return root;
}
public TestTreeNode BuildTree(IProgressMonitor progressMonitor, TestModelData testModelData,
TreeBuilderOptions options)
{
var root = new TestDataNode(testModelData.RootTest);
progressMonitor.Worked(1);
PopulateNamespaceTree(progressMonitor, testModelData.RootTest.Children,
root, options);
return(root);
}
private static void PopulateMetadataTree(IProgressMonitor progressMonitor, string metadataType,
TestData testData, Node parentNode, TestTreeNode rootNode)
{
TestDataNode testDataNode = AddMetadataNode(testData, metadataType,
rootNode, parentNode);
foreach (var childTestData in testData.Children)
{
PopulateMetadataTree(progressMonitor, metadataType, childTestData,
testDataNode, rootNode);
}
progressMonitor.Worked(1);
}
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions options, IProgressMonitor progressMonitor)
{
AttachmentContentDisposition attachmentContentDisposition = GetAttachmentContentDisposition(options);
using (progressMonitor.BeginTask("Formatting report.", 10))
{
progressMonitor.SetStatus("Applying template.");
ApplyTemplate(reportWriter, attachmentContentDisposition, options);
progressMonitor.Worked(3);
progressMonitor.SetStatus("Copying resources.");
CopyResources(reportWriter);
progressMonitor.Worked(2);
progressMonitor.SetStatus(@"");
if (attachmentContentDisposition == AttachmentContentDisposition.Link)
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
reportWriter.SaveReportAttachments(subProgressMonitor);
}
}
}
private static void PopulateMetadataTree(IProgressMonitor progressMonitor, string metadataType,
TestData testData, Node parentNode, TestTreeNode rootNode)
{
TestDataNode testDataNode = AddMetadataNode(testData, metadataType,
rootNode, parentNode);
foreach (var childTestData in testData.Children)
{
PopulateMetadataTree(progressMonitor, metadataType, childTestData,
testDataNode, rootNode);
}
progressMonitor.Worked(1);
}
/// <inheritdoc />
public void SaveReport(AttachmentContentDisposition attachmentContentDisposition,
IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
{
throw new ArgumentNullException(@"progressMonitor");
}
if (reportSaved)
{
return;
}
int attachmentCount = CountAttachments(report);
using (progressMonitor.BeginTask("Saving report.", attachmentCount + 1))
{
var encoding = new UTF8Encoding(false);
var settings = new XmlWriterSettings();
settings.CheckCharacters = false;
settings.Indent = true;
settings.Encoding = encoding;
settings.CloseOutput = true;
string reportPath = reportContainer.ReportName + @".xml";
progressMonitor.ThrowIfCanceled();
progressMonitor.SetStatus(reportPath);
using (XmlWriter writer = XmlWriter.Create(reportContainer.OpenWrite(reportPath, MimeTypes.Xml, settings.Encoding), settings))
{
progressMonitor.ThrowIfCanceled();
SerializeReport(writer, attachmentContentDisposition);
}
progressMonitor.Worked(1);
progressMonitor.SetStatus(@"");
if (attachmentContentDisposition == AttachmentContentDisposition.Link && attachmentCount != 0)
{
progressMonitor.ThrowIfCanceled();
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(attachmentCount))
SaveReportAttachments(subProgressMonitor);
}
AddReportDocumentPath(reportPath);
reportSaved = true;
}
}
public TestTreeNode BuildTree(IProgressMonitor progressMonitor,
TestModelData testModelData, TreeBuilderOptions options)
{
var root = new TestDataNode(testModelData.RootTest);
progressMonitor.Worked(1);
foreach (var childTestData in testModelData.RootTest.Children)
{
PopulateMetadataTree(progressMonitor, options.TreeViewCategory,
childTestData, null, root);
}
return(root);
}
public TestTreeNode BuildTree(IProgressMonitor progressMonitor,
TestModelData testModelData, TreeBuilderOptions options)
{
var root = new TestDataNode(testModelData.RootTest);
progressMonitor.Worked(1);
foreach (var childTestData in testModelData.RootTest.Children)
{
PopulateMetadataTree(progressMonitor, options.TreeViewCategory,
childTestData, null, root);
}
return root;
}
public override void Install(IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Installing TestDriven.Net Runner", testFrameworkManager.TestFrameworkHandles.Count + 2))
{
// Remove old registrations.
RemoveExistingRegistryKeys(progressMonitor);
progressMonitor.Worked(1);
// Register Icarus
string icarusPath = FindIcarusPath();
if (icarusPath != null)
{
InstallRegistryKeysForIcarus(icarusPath, progressMonitor);
}
progressMonitor.Worked(1);
// Register frameworks
foreach (ComponentHandle <ITestFramework, TestFrameworkTraits> testFrameworkHandle in testFrameworkManager.TestFrameworkHandles)
{
TestFrameworkTraits testFrameworkTraits = testFrameworkHandle.GetTraits();
TDNetRunnerInstallationMode installationMode = preferenceManager.GetInstallationModeForFramework(testFrameworkHandle.Id);
if (installationMode != TDNetRunnerInstallationMode.Disabled)
{
int priority = installationMode == TDNetRunnerInstallationMode.Default ? 25 : 5;
foreach (AssemblySignature frameworkAssembly in testFrameworkTraits.FrameworkAssemblies)
{
InstallRegistryKeysForFramework(testFrameworkTraits.Name, frameworkAssembly, priority,
progressMonitor);
}
}
progressMonitor.Worked(1);
}
}
}
public void AddFiles(IProgressMonitor progressMonitor, IList <string> files)
{
using (progressMonitor.BeginTask(Resources.AddingFiles, (files.Count + 2)))
{
var validFiles = GetValidFiles(progressMonitor, files);
GenericCollectionUtils.ForEach(validFiles, x =>
TestPackage.AddFile(new FileInfo(x)));
projectTreeModel.NotifyTestProjectChanged();
progressMonitor.Worked(1);
fileWatcher.Add(validFiles);
}
}
public void Run(bool debug, IProgressMonitor progressMonitor,
IEnumerable <string> testRunnerExtensions)
{
using (progressMonitor.BeginTask("Running the tests.", 100))
{
eventAggregator.Send(this, new RunStarted());
testsFailed = false;
progressMonitor.Worked(5);
DoWithTestRunner(testRunner => RunTests(debug, testRunner, progressMonitor),
progressMonitor, 5, testRunnerExtensions);
eventAggregator.Send(this, new RunFinished());
}
}
private static void PopulateNamespaceTree(IProgressMonitor progressMonitor, IList<TestData> list,
TestTreeNode parent, TreeBuilderOptions options)
{
for (var i = 0; i < list.Count; i++)
{
var testData = list[i];
var testTreeNode = AddNode(testData, parent,
options);
// process child nodes
PopulateNamespaceTree(progressMonitor, testData.Children, testTreeNode,
options);
progressMonitor.Worked(1);
}
}
private static void PopulateNamespaceTree(IProgressMonitor progressMonitor, IList <TestData> list,
TestTreeNode parent, TreeBuilderOptions options)
{
for (var i = 0; i < list.Count; i++)
{
var testData = list[i];
var testTreeNode = AddNode(testData, parent,
options);
// process child nodes
PopulateNamespaceTree(progressMonitor, testData.Children, testTreeNode,
options);
progressMonitor.Worked(1);
}
}
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));
}
}
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 IList <string> GetValidFiles(IProgressMonitor progressMonitor, IEnumerable <string> files)
{
var validFiles = new List <string>();
foreach (string file in files)
{
var filePath = Path.GetFullPath(file);
if (fileSystem.FileExists(filePath))
{
validFiles.Add(filePath);
}
progressMonitor.Worked(1);
}
return(validFiles);
}
public override void OnSpecificationEnd(SpecificationInfo specification, Result result)
{
_listener.OnSpecificationEnd(specification, result);
ITestContext testContext = _contextsBySpec[specification.Name];
testContext.LifecyclePhase = LifecyclePhases.Finishing;
TestOutcome outcome;
TimeSpan? span = null;
if (result.Status == Status.NotImplemented)
{
TestLog.Warnings.WriteLine("{0} ({1})", specification.Name, "NOT IMPLEMENTED");
TestLog.Warnings.Flush();
outcome = TestOutcome.Pending;
span = new TimeSpan(0);
}
else if (result.Status == Status.Ignored)
{
TestLog.Warnings.WriteLine("{0} ({1})", specification.Name, "IGNORED");
TestLog.Warnings.Flush();
outcome = TestOutcome.Ignored;
span = new TimeSpan(0);
}
else if (result.Passed)
{
outcome = TestOutcome.Passed;
}
else
{
TestLog.Failures.WriteException(Convert(result.Exception));
TestLog.Failures.Flush();
outcome = TestOutcome.Failed;
}
testContext.FinishStep(outcome, span);
_outcome = _outcome.CombineWith(outcome);
_progressMonitor.Worked(1);
}
/// <inheritdoc />
public void Dispose(IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
{
throw new ArgumentNullException("progressMonitor");
}
if (state == State.Disposed)
{
return;
}
using (progressMonitor.BeginTask("Disposing the test runner.", 10))
{
bool success;
try
{
eventDispatcher.NotifyDisposeStarted(new DisposeStartedEventArgs());
if (testIsolationContext != null)
{
progressMonitor.SetStatus("Disposing the test isolation context.");
testIsolationContext.Dispose();
testIsolationContext = null;
}
progressMonitor.Worked(10);
success = true;
}
catch (Exception ex)
{
if (tappedLogger != null)
{
tappedLogger.Log(LogSeverity.Warning, "An exception occurred while disposing the test isolation context. This may indicate that the test isolation context previously encountered another fault from which it could not recover.", ex);
}
success = false;
}
state = State.Disposed;
eventDispatcher.NotifyDisposeFinished(new DisposeFinishedEventArgs(success));
UnhandledExceptionPolicy.ReportUnhandledException -= OnUnhandledException;
}
}
private TestModel PublishTestModelFromCodeElements(IEnumerable <ICodeElementInfo> codeElements, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
TestModel testModel = new TestModel();
var tests = new Dictionary <ICodeElementInfo, Test>();
foreach (ICodeElementInfo codeElement in codeElements)
{
if (progressMonitor.IsCanceled)
{
return(null);
}
testModel.AddAnnotation(new Annotation(AnnotationType.Warning, codeElement, FallbackExplanation));
IAssemblyInfo assembly = ReflectionUtils.GetAssembly(codeElement);
if (assembly != null)
{
Test assemblyTest;
if (!tests.TryGetValue(assembly, out assemblyTest))
{
assemblyTest = CreateTest(Path.GetFileName(assembly.Path), assembly);
testModel.RootTest.AddChild(assemblyTest);
tests.Add(assembly, assemblyTest);
ITypeInfo type = ReflectionUtils.GetType(codeElement);
if (type != null)
{
Test typeTest;
if (!tests.TryGetValue(type, out typeTest))
{
typeTest = CreateTest(type.Name, type);
assemblyTest.AddChild(typeTest);
tests.Add(type, typeTest);
}
}
}
}
progressMonitor.Worked(1);
}
TestModelSerializer.PublishTestModel(testModel, messageSink);
return(testModel);
}
public void OpenProject(IProgressMonitor progressMonitor, string projectLocation)
{
using (progressMonitor.BeginTask(Resources.ProjectController_Loading_project_file, 100))
{
var testProject = new TestProject();
try
{
testProject = testProjectManager.LoadProject(new FileInfo(projectLocation));
}
catch (Exception ex)
{
unhandledExceptionPolicy.Report(Resources.ProjectController_Error_loading_project_file, ex);
}
progressMonitor.Worked(50);
LoadProject(testProject, projectLocation);
}
}
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);
}
private static TestResult RunTest(ITestCommand testCommand, TestStep parentTestStep, IProgressMonitor progressMonitor)
{
Test test = testCommand.Test;
progressMonitor.SetStatus(test.Name);
TestResult result;
XunitTest xunitTest = test as XunitTest;
if (xunitTest == null)
{
result = RunChildTests(testCommand, parentTestStep, progressMonitor);
}
else
{
result = RunTestFixture(testCommand, xunitTest.TypeInfo, parentTestStep);
}
progressMonitor.Worked(1);
return result;
}
private void HandleTestOrSuiteFinished(NUnit.Core.TestResult nunitResult)
{
if (testContextStack.Count == 0)
{
return;
}
ITestContext testContext = testContextStack.Peek();
NUnitTest test = (NUnitTest)testContext.TestStep.Test;
if (test.Test.TestName != nunitResult.Test.TestName)
{
return;
}
testContextStack.Pop();
progressMonitor.Worked(1);
string logStreamName = nunitResult.ResultState == ResultState.Success ? MarkupStreamNames.Warnings : MarkupStreamNames.Failures;
MarkupDocumentWriter logWriter = testContext.LogWriter;
if (nunitResult.Message != null)
{
using (logWriter[logStreamName].BeginSection(Resources.NUnitTestController_ResultMessageSectionName))
logWriter[logStreamName].Write(nunitResult.Message);
}
if (nunitResult.StackTrace != null)
{
using (logWriter[logStreamName].BeginSection(Resources.NUnitTestController_ResultStackTraceSectionName))
using (logWriter[logStreamName].BeginMarker(Marker.StackTrace))
logWriter[logStreamName].Write(nunitResult.StackTrace);
}
testContext.AddAssertCount(nunitResult.AssertCount);
TestResult result = testContext.FinishStep(CreateOutcomeFromResult(nunitResult), null);
if (testContextStack.Count == 0)
{
topResult = result;
}
}
private static TestResult RunTest(ITestCommand testCommand, TestStep parentTestStep, IProgressMonitor progressMonitor)
{
Test test = testCommand.Test;
progressMonitor.SetStatus(test.Name);
TestResult result;
ConcordionTest concordionTest = test as ConcordionTest;
if (concordionTest == null)
{
result = RunChildTests(testCommand, parentTestStep, progressMonitor);
}
else
{
result = RunTestFixture(testCommand, concordionTest, parentTestStep);
}
progressMonitor.Worked(1);
return result;
}
public void Execute(IProgressMonitor progressMonitor)
{
var testFilters = projectController.TestFilters.Value;
var totalWorkUnits = testFilters.Count > 0 ? testFilters.Count : 1;
using (progressMonitor.BeginTask("Restoring test filter", totalWorkUnits))
{
foreach (var filterInfo in testFilters)
{
if (filterInfo.FilterName != FilterName)
{
progressMonitor.Worked(1);
continue;
}
ApplyFilter(progressMonitor, filterInfo);
return;
}
}
}
/// <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);
}
}
}
}
/// <summary>
/// Called automatically when isolation task is ready to run.
/// </summary>
protected override object RunImpl(object[] args)
{
file_ = (FileInfo)args[0];
architecture_ = (string)args[1];
configuration_ = (string)args[2];
testExecutionOptions_ = (TestExecutionOptions)args[3];
logger_ = (ILogger)args[4];
progressMonitor_ = (IProgressMonitor)args[5];
using (QueuedMessageSink sink = new QueuedMessageSink((IMessageSink)args[6]))
{
messageSink_ = sink;
testModel_ = new TestModel();
currentTest_ = testModel_.RootTest;
currentTestSuite_ = testModel_.RootTest;
using (progressMonitor_.BeginTask("Processing " + file_.Name, 100))
{
// Expect native DLL to be reachable in subdirectory relative to the current assembly path.
string assemblyDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string suffix = Path.Combine(architecture_, configuration_);
// Make sure we can find the right version of Boost.Test DLL.
if (!SetDllDirectory(Path.Combine(assemblyDir, suffix)))
{
Logger.Log(
LogSeverity.Error,
String.Format(
"Failed to adjust DLL directory search path: {0}",
new Win32Exception(Marshal.GetLastWin32Error()).Message
)
);
return null;
}
// Try loading native bridge DLL.
IntPtr hModule = LoadLibrary(Path.Combine(assemblyDir, Path.Combine(suffix, NativeDllName)));
if (hModule == IntPtr.Zero)
{
Logger.Log(
LogSeverity.Error,
String.Format(
"Failed to load native DLL to communicate with Boost.Test: {0}",
new Win32Exception(Marshal.GetLastWin32Error()).Message
)
);
return null;
}
try
{
// Make sure we allow loading additional DLLs
// from the same folder our testable DLL is located in.
if (!SetDllDirectory(File.DirectoryName))
{
Logger.Log(
LogSeverity.Error,
String.Format(
"Failed to adjust DLL directory search path: {0}",
new Win32Exception(Marshal.GetLastWin32Error()).Message
)
);
return null;
}
progressMonitor_.Worked(14);
// Retrieve pointer to function in native bridge DLL that is required to
// perform our task.
IntPtr bridgeFunc = GetProcAddress(hModule, BridgeFunctionName);
if (bridgeFunc == IntPtr.Zero)
{
Logger.Log(
LogSeverity.Error,
String.Format(
"Failed to retrieve entry point {0} in Boost.Test interface: {1}",
BridgeFunctionName,
new Win32Exception(Marshal.GetLastWin32Error()).Message
)
);
return null;
}
progressMonitor_.Worked(1);
// Perform the task.
Execute(bridgeFunc, progressMonitor_.CreateSubProgressMonitor(80));
}
finally
{
FreeLibrary(hModule);
progressMonitor_.Worked(5);
}
}
}
return null;
}
/// <inheritdoc />
public Report LoadReport(bool loadAttachmentContents, IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
throw new ArgumentNullException(@"progressMonitor");
using (progressMonitor.BeginTask(String.Format("Loading report '{0}'.", reportContainer.ReportName), 10))
{
string reportPath = reportContainer.ReportName + @".xml";
progressMonitor.ThrowIfCanceled();
progressMonitor.SetStatus(reportPath);
var serializer = new XmlSerializer(typeof(Report));
Report report;
using (Stream stream = reportContainer.OpenRead(reportPath))
{
progressMonitor.ThrowIfCanceled();
report = (Report)serializer.Deserialize(stream);
}
FixImplicitIds(report);
progressMonitor.Worked(1);
progressMonitor.SetStatus(@"");
if (loadAttachmentContents)
{
progressMonitor.ThrowIfCanceled();
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(9))
LoadReportAttachments(report, subProgressMonitor);
}
return report;
}
}
private TestModel PublishTestModelFromCodeElements(IEnumerable<ICodeElementInfo> codeElements, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
TestModel testModel = new TestModel();
var tests = new Dictionary<ICodeElementInfo, Test>();
foreach (ICodeElementInfo codeElement in codeElements)
{
if (progressMonitor.IsCanceled)
return null;
testModel.AddAnnotation(new Annotation(AnnotationType.Warning, codeElement, FallbackExplanation));
IAssemblyInfo assembly = ReflectionUtils.GetAssembly(codeElement);
if (assembly != null)
{
Test assemblyTest;
if (!tests.TryGetValue(assembly, out assemblyTest))
{
assemblyTest = CreateTest(Path.GetFileName(assembly.Path), assembly);
testModel.RootTest.AddChild(assemblyTest);
tests.Add(assembly, assemblyTest);
ITypeInfo type = ReflectionUtils.GetType(codeElement);
if (type != null)
{
Test typeTest;
if (!tests.TryGetValue(type, out typeTest))
{
typeTest = CreateTest(type.Name, type);
assemblyTest.AddChild(typeTest);
tests.Add(type, typeTest);
}
}
}
}
progressMonitor.Worked(1);
}
TestModelSerializer.PublishTestModel(testModel, messageSink);
return testModel;
}
private TestModel PublishTestModelFromFiles(IEnumerable<FileInfo> files, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
TestModel testModel = new TestModel();
foreach (FileInfo file in files)
{
if (progressMonitor.IsCanceled)
return null;
messageSink.Publish(new AnnotationDiscoveredMessage()
{
Annotation = new AnnotationData(AnnotationType.Warning,
new CodeLocation(file.FullName, 0, 0),
CodeReference.Unknown,
string.Format("File '{0}' is not supported by any installed test framework. It will be ignored.", file.Name), null)
});
Test fileTest = CreateTest(file.Name, null);
fileTest.Metadata.Add(MetadataKeys.File, file.FullName);
testModel.RootTest.AddChild(fileTest);
progressMonitor.Worked(1);
}
TestModelSerializer.PublishTestModel(testModel, messageSink);
return testModel;
}
/// <inheritdoc />
protected override sealed void RunAssembly(Assembly assembly, TestExplorationOptions testExplorationOptions, TestExecutionOptions testExecutionOptions, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask(string.Format("Running {0} tests.", FrameworkName), 100))
{
using (TestHarness testHarness = CreateTestHarness())
{
IDisposable appDomainState = null;
try
{
progressMonitor.SetStatus("Setting up the test harness.");
appDomainState = testHarness.SetUpAppDomain();
progressMonitor.Worked(1);
progressMonitor.SetStatus("Building the test model.");
TestModel testModel = GenerateTestModel(assembly, messageSink);
progressMonitor.Worked(3);
progressMonitor.SetStatus("Building the test commands.");
ITestContextManager testContextManager = CreateTestContextManager(messageSink);
ITestCommand rootTestCommand = GenerateCommandTree(testModel, testExecutionOptions, testContextManager);
progressMonitor.Worked(2);
progressMonitor.SetStatus("Running the tests.");
if (rootTestCommand != null)
{
RunTestCommandsAction action = new RunTestCommandsAction(this, rootTestCommand, testExecutionOptions,
testHarness, testContextManager, progressMonitor.CreateSubProgressMonitor(93));
if (testExecutionOptions.SingleThreaded)
{
// The execution options require the use of a single thread.
action.Run();
}
else
{
// Create a new thread so that we can consistently set the default apartment
// state to STA and so as to reduce the effective stack depth during the
// test run. We use Thread instead of ThreadTask because we do not
// require the ability to abort the Thread so we do not need to take the
// extra overhead.
Thread thread = new Thread(action.Run);
thread.Name = "Simple Test Driver";
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
thread.Join();
}
if (action.Exception != null)
throw new ModelException("A fatal exception occurred while running test commands.", action.Exception);
}
else
{
progressMonitor.Worked(93);
}
}
finally
{
progressMonitor.SetStatus("Tearing down the test harness.");
if (appDomainState != null)
appDomainState.Dispose();
progressMonitor.Worked(1);
}
}
}
}
private bool ApplySettingsChanges(IElevationContext elevationContext, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Applying changes.", 1))
{
var tabs = new List<ControlPanelTab>(GetControlPanelTabs());
if (tabs.Count == 0)
return true;
double workPerTab = 1.0 / tabs.Count;
foreach (ControlPanelTab tab in tabs)
{
if (progressMonitor.IsCanceled)
return false;
if (tab.PendingSettingsChanges)
{
tab.ApplyPendingSettingsChanges(tab.RequiresElevation ? elevationContext : null, progressMonitor.CreateSubProgressMonitor(workPerTab));
}
else
{
progressMonitor.Worked(workPerTab);
}
}
}
return true;
}
/// <inheritdoc />
public void SaveReportAttachments(IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
throw new ArgumentNullException(@"progressMonitor");
if (reportAttachmentsSaved)
return;
int attachmentCount = CountAttachments(report);
if (attachmentCount == 0)
return;
using (progressMonitor.BeginTask("Saving report attachments.", attachmentCount))
{
foreach (TestStepRun testStepRun in report.TestPackageRun.AllTestStepRuns)
{
foreach (AttachmentData attachment in testStepRun.TestLog.Attachments)
{
string attachmentPath = attachmentPathResolver.GetAttachmentPath(testStepRun.Step.Id, attachment.Name, attachment.ContentType);
progressMonitor.ThrowIfCanceled();
progressMonitor.SetStatus(attachmentPath);
SaveAttachmentContents(attachment, attachmentPath);
progressMonitor.Worked(1);
}
}
reportAttachmentsSaved = true;
}
}
/// <inheritdoc />
public void Dispose(IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
throw new ArgumentNullException("progressMonitor");
if (state == State.Disposed)
return;
using (progressMonitor.BeginTask("Disposing the test runner.", 10))
{
bool success;
try
{
eventDispatcher.NotifyDisposeStarted(new DisposeStartedEventArgs());
if (testIsolationContext != null)
{
progressMonitor.SetStatus("Disposing the test isolation context.");
testIsolationContext.Dispose();
testIsolationContext = null;
}
progressMonitor.Worked(10);
success = true;
}
catch (Exception ex)
{
if (tappedLogger != null)
tappedLogger.Log(LogSeverity.Warning, "An exception occurred while disposing the test isolation context. This may indicate that the test isolation context previously encountered another fault from which it could not recover.", ex);
success = false;
}
state = State.Disposed;
eventDispatcher.NotifyDisposeFinished(new DisposeFinishedEventArgs(success));
UnhandledExceptionPolicy.ReportUnhandledException -= OnUnhandledException;
}
}
/// <inheritdoc />
public void Initialize(TestRunnerOptions testRunnerOptions, ILogger logger, IProgressMonitor progressMonitor)
{
if (testRunnerOptions == null)
throw new ArgumentNullException("testRunnerOptions");
if (logger == null)
throw new ArgumentNullException("logger");
if (progressMonitor == null)
throw new ArgumentNullException("progressMonitor");
ThrowIfDisposed();
if (state != State.Created)
throw new InvalidOperationException("The test runner has already been initialized.");
testRunnerOptions = testRunnerOptions.Copy();
this.testRunnerOptions = testRunnerOptions;
tappedLogger = new TappedLogger(this, logger);
int extensionCount = extensions.Count;
using (progressMonitor.BeginTask("Initializing the test runner.", 1 + extensionCount))
{
foreach (ITestRunnerExtension extension in extensions)
{
string extensionName = extension.GetType().Name; // TODO: improve me
progressMonitor.SetStatus(String.Format("Installing extension '{0}'.", extensionName));
try
{
// Note: We don't pass the tapped logger to the extensions because the
// extensions frequently write to the console a bunch of information we
// already have represented in the report. We are more interested in what
// the test driver has to tell us.
extension.Install(eventDispatcher, logger);
progressMonitor.Worked(1);
}
catch (Exception ex)
{
throw new RunnerException(String.Format("Failed to install extension '{0}'.", extensionName), ex);
}
progressMonitor.SetStatus("");
}
try
{
UnhandledExceptionPolicy.ReportUnhandledException += OnUnhandledException;
eventDispatcher.NotifyInitializeStarted(new InitializeStartedEventArgs(testRunnerOptions));
progressMonitor.SetStatus("Initializing the test isolation context.");
TestIsolationOptions testIsolationOptions = new TestIsolationOptions();
GenericCollectionUtils.ForEach(testRunnerOptions.Properties, x => testIsolationOptions.AddProperty(x.Key, x.Value));
testIsolationContext = testIsolationProvider.CreateContext(testIsolationOptions, tappedLogger);
progressMonitor.Worked(1);
}
catch (Exception ex)
{
eventDispatcher.NotifyInitializeFinished(new InitializeFinishedEventArgs(false));
UnhandledExceptionPolicy.ReportUnhandledException -= OnUnhandledException;
throw new RunnerException("A fatal exception occurred while initializing the test isolation context.", ex);
}
state = State.Initialized;
eventDispatcher.NotifyInitializeFinished(new InitializeFinishedEventArgs(true));
}
}
private void ExploreOrRunAssembly(ITestIsolationContext testIsolationContext, TestPackage testPackage, TestExplorationOptions testExplorationOptions,
TestExecutionOptions testExecutionOptions, RemoteMessageSink remoteMessageSink, IProgressMonitor progressMonitor, string taskName,
FileInfo file)
{
using (progressMonitor.BeginTask(taskName, 100))
{
if (progressMonitor.IsCanceled)
return;
string assemblyPath = file.FullName;
progressMonitor.SetStatus("Getting test assembly metadata.");
AssemblyMetadata assemblyMetadata = AssemblyUtils.GetAssemblyMetadata(assemblyPath, AssemblyMetadataFields.RuntimeVersion);
progressMonitor.Worked(2);
if (progressMonitor.IsCanceled)
return;
if (assemblyMetadata != null)
{
Type driverType = GetType();
object[] driverArguments = GetRemoteTestDriverArguments();
HostSetup hostSetup = CreateHostSetup(testPackage, assemblyPath, assemblyMetadata);
using (var remoteProgressMonitor = new RemoteProgressMonitor(
progressMonitor.CreateSubProgressMonitor(97)))
{
testIsolationContext.RunIsolatedTask<ExploreOrRunTask>(hostSetup,
(statusMessage) => progressMonitor.SetStatus(statusMessage),
new object[] { driverType, driverArguments, assemblyPath, testExplorationOptions, testExecutionOptions, remoteMessageSink, remoteProgressMonitor });
}
// Record one final work unit after the isolated task has been fully cleaned up.
progressMonitor.SetStatus("");
progressMonitor.Worked(1);
}
}
}
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions options, IProgressMonitor progressMonitor)
{
AttachmentContentDisposition attachmentContentDisposition = GetAttachmentContentDisposition(options);
using (progressMonitor.BeginTask("Formatting report.", 10))
{
progressMonitor.SetStatus("Applying XSL transform.");
ApplyTransform(reportWriter, attachmentContentDisposition, options);
progressMonitor.Worked(3);
progressMonitor.SetStatus("Copying resources.");
CopyResources(reportWriter);
progressMonitor.Worked(2);
progressMonitor.SetStatus(@"");
if (attachmentContentDisposition == AttachmentContentDisposition.Link)
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
reportWriter.SaveReportAttachments(subProgressMonitor);
}
}
}
private TestResult RunTestStep(ITestCommand testCommand, TestInfoData testStepInfo, TestStep parentTestStep, IProgressMonitor progressMonitor)
{
ITestContext testContext = testCommand.StartPrimaryChildStep(parentTestStep);
TestStepResult testStepResult = repository.RunTest(testStepInfo);
reporter.Run(testContext, testStepInfo, testStepResult);
WriteToTestLog(testContext, testStepResult);
testContext.AddAssertCount(testStepResult.AssertCount);
progressMonitor.Worked(1);
return testContext.FinishStep(testStepResult.TestOutcome, testStepResult.Duration);
}
private void RunTestModel(TestModel testModel, IMessageSink messageSink, IProgressMonitor progressMonitor, double totalWork)
{
double workUnitsPerStep = totalWork / (1 + testModel.RootTest.Children.Count);
TestStep rootTestStep = new TestStep(testModel.RootTest, null);
messageSink.Publish(new TestStepStartedMessage()
{
Step = new TestStepData(rootTestStep)
});
foreach (Test test in testModel.RootTest.Children)
{
if (progressMonitor.IsCanceled)
return;
TestStep testStep = new TestStep(test, rootTestStep);
messageSink.Publish(new TestStepStartedMessage()
{
Step = new TestStepData(testStep)
});
messageSink.Publish(new TestStepLogStreamWriteMessage()
{
StepId = testStep.Id,
StreamName = MarkupStreamNames.Warnings,
Text = FallbackExplanation
});
messageSink.Publish(new TestStepFinishedMessage()
{
StepId = testStep.Id,
Result = new TestResult(TestOutcome.Ignored)
});
progressMonitor.Worked(workUnitsPerStep);
}
messageSink.Publish(new TestStepFinishedMessage()
{
StepId = rootTestStep.Id,
Result = new TestResult(TestOutcome.Skipped)
});
progressMonitor.Worked(workUnitsPerStep);
}
/// <inheritdoc />
public void SaveReport(AttachmentContentDisposition attachmentContentDisposition,
IProgressMonitor progressMonitor)
{
if (progressMonitor == null)
throw new ArgumentNullException(@"progressMonitor");
if (reportSaved)
return;
int attachmentCount = CountAttachments(report);
using (progressMonitor.BeginTask("Saving report.", attachmentCount + 1))
{
var encoding = new UTF8Encoding(false);
var settings = new XmlWriterSettings();
settings.CheckCharacters = false;
settings.Indent = true;
settings.Encoding = encoding;
settings.CloseOutput = true;
string reportPath = reportContainer.ReportName + @".xml";
progressMonitor.ThrowIfCanceled();
progressMonitor.SetStatus(reportPath);
using (XmlWriter writer = XmlWriter.Create(reportContainer.OpenWrite(reportPath, MimeTypes.Xml, settings.Encoding), settings))
{
progressMonitor.ThrowIfCanceled();
SerializeReport(writer, attachmentContentDisposition);
}
progressMonitor.Worked(1);
progressMonitor.SetStatus(@"");
if (attachmentContentDisposition == AttachmentContentDisposition.Link && attachmentCount != 0)
{
progressMonitor.ThrowIfCanceled();
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(attachmentCount))
SaveReportAttachments(subProgressMonitor);
}
AddReportDocumentPath(reportPath);
reportSaved = true;
}
}
/// <inheritdoc />
protected override sealed void ExploreAssembly(Assembly assembly, TestExplorationOptions testExplorationOptions, IMessageSink messageSink, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask(string.Format("Exploring {0} tests.", FrameworkName), 5))
{
using (TestHarness testHarness = CreateTestHarness())
{
IDisposable appDomainState = null;
try
{
progressMonitor.SetStatus("Setting up the test harness.");
appDomainState = testHarness.SetUpAppDomain();
progressMonitor.Worked(1);
progressMonitor.SetStatus("Building the test model.");
GenerateTestModel(assembly, messageSink);
progressMonitor.Worked(3);
}
finally
{
progressMonitor.SetStatus("Tearing down the test harness.");
if (appDomainState != null)
appDomainState.Dispose();
progressMonitor.Worked(1);
}
}
}
}
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;
}
private TestResult RunTest(ITestCommand testCommand, TestStep parentTestStep, IProgressMonitor progressMonitor)
{
Test test = testCommand.Test;
progressMonitor.SetStatus(test.Name);
// The first test should be an assembly test
MSTestAssembly assemblyTest = testCommand.Test as MSTestAssembly;
TestOutcome outcome;
TestResult result;
if (assemblyTest != null)
{
ITestContext assemblyContext = testCommand.StartPrimaryChildStep(parentTestStep);
try
{
MSTestRunner runner = MSTestRunner.GetRunnerForFrameworkVersion(frameworkVersion);
outcome = runner.RunSession(assemblyContext, assemblyTest,
testCommand, parentTestStep, progressMonitor);
}
catch (Exception ex)
{
assemblyContext.LogWriter.Failures.WriteException(ex, "Internal Error");
outcome = TestOutcome.Error;
}
result = assemblyContext.FinishStep(outcome, null);
}
else
{
result = new TestResult(TestOutcome.Skipped);
}
progressMonitor.Worked(1);
return result;
}
