public ProjectController(IProjectTreeModel projectTreeModel, IEventAggregator eventAggregator, IFileSystem fileSystem,
IFileWatcher fileWatcher, IUnhandledExceptionPolicy unhandledExceptionPolicy, ITestProjectManager testProjectManager)
{
this.projectTreeModel = projectTreeModel;
this.eventAggregator = eventAggregator;
this.fileSystem = fileSystem;
this.fileWatcher = fileWatcher;
this.unhandledExceptionPolicy = unhandledExceptionPolicy;
this.testProjectManager = testProjectManager;
TestFilters = new Observable <IList <FilterInfo> >(new List <FilterInfo>());
TestFilters.PropertyChanged += (s, e) =>
{
if (updating)
{
return;
}
projectTreeModel.TestProject.ClearTestFilters();
GenericCollectionUtils.ForEach(TestFilters.Value, x =>
projectTreeModel.TestProject.AddTestFilter(x));
};
fileWatcher.FileChangedEvent += delegate(string fullPath)
{
string fileName = Path.GetFileName(fullPath);
EventHandlerPolicy.SafeInvoke(FileChanged, this, new FileChangedEventArgs(fileName));
};
}
private RuntimeSetup CreateRuntimeSetup()
{
var runtimeSetup = new RuntimeSetup();
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, runtimeSetup.AddPluginDirectory);
return(runtimeSetup);
}
/// <inheritdoc />
protected override int RunImpl(string[] args)
{
if (!ParseArguments(args))
{
ShowHelp();
return(1);
}
if (Arguments.Help)
{
ShowHelp();
return(0);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var runtimeSetup = new RuntimeSetup();
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => runtimeSetup.AddPluginDirectory(x));
ILogger logger = new FilteredLogger(new RichConsoleLogger(Console), Verbosity.Normal);
using (RuntimeBootstrap.Initialize(runtimeSetup, logger))
{
IControlPanelPresenter presenter = RuntimeAccessor.Instance.ServiceLocator.Resolve <IControlPanelPresenter>();
presenter.Show(null);
}
return(0);
}
protected override void ShowHelp()
{
// Show argument only help first because what we do next might take a little while
// and we want to make the program appear responsive.
base.ShowHelp();
// Print out options related to the currently available set of plugins.
var setup = new RuntimeSetup();
if (Arguments != null && Arguments.PluginDirectories != null)
{
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => setup.AddPluginDirectory(x));
}
using (RuntimeBootstrap.Initialize(setup, CreateLogger()))
{
IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>();
ShowRegisteredComponents("Supported report types:", reportManager.FormatterHandles,
h => h.GetTraits().Name, h => h.GetTraits().Description);
ITestRunnerManager runnerManager = RuntimeAccessor.ServiceLocator.Resolve <ITestRunnerManager>();
ShowRegisteredComponents("Supported runner types:", runnerManager.TestRunnerFactoryHandles,
h => h.GetTraits().Name, h => h.GetTraits().Description);
}
}
/// <inheritdoc />
protected override int RunImpl(string[] args)
{
if (!ParseArguments(args))
{
ShowHelp();
return(1);
}
if (Arguments.Help)
{
ShowHelp();
return(0);
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
UnhandledErrorPolicy();
var runtimeSetup = new RuntimeSetup
{
RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation(
typeof(IcarusProgram).Assembly))
};
var runtimeLogger = new RuntimeLogger();
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, runtimeSetup.AddPluginDirectory);
using (RuntimeBootstrap.Initialize(runtimeSetup, runtimeLogger))
{
// wire up services & components
var scanner = new DefaultConventionScanner(RuntimeAccessor.Registry);
scanner.Scan("Gallio.Icarus", Assembly.GetExecutingAssembly());
LoadPackages();
var optionsController = RuntimeAccessor.ServiceLocator.Resolve <IOptionsController>();
// create & initialize a test runner whenever the test runner factory is changed
optionsController.TestRunnerFactory.PropertyChanged += (s, e) =>
ConfigureTestRunnerFactory(optionsController.TestRunnerFactory);
ConfigureTestRunnerFactory(optionsController.TestRunnerFactory);
var runtimeLogController = RuntimeAccessor.ServiceLocator.Resolve <IRuntimeLogController>();
runtimeLogController.SetLogger(runtimeLogger);
var applicationController = RuntimeAccessor.ServiceLocator.Resolve <IApplicationController>();
applicationController.Arguments = Arguments;
ErrorDialogUnhandledExceptionHandler.RunApplicationWithHandler(new Main(applicationController));
UnloadPackages();
}
return(ResultCode.Success);
}
private void LoadProject(TestProject testProject, string projectLocation)
{
projectTreeModel.FileName = projectLocation;
projectTreeModel.TestProject = testProject;
fileWatcher.Clear();
GenericCollectionUtils.ForEach(testProject.TestPackage.Files, x => fileWatcher.Add(x.FullName));
PublishUpdates();
eventAggregator.Send(this, new ProjectLoaded(projectLocation));
}
/// <summary>
/// Initializes a test project with the contents of this structure.
/// </summary>
/// <param name="testProject">The test project to populate.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="testProject"/> is null.</exception>
public void InitializeTestProject(TestProject testProject)
{
if (testProject == null)
{
throw new ArgumentNullException("testProject");
}
testPackage.InitializeTestPackage(testProject.TestPackage);
GenericCollectionUtils.ForEach(testFilters, x => testProject.AddTestFilter(x));
GenericCollectionUtils.ForEach(testRunnerExtensions, x => testProject.AddTestRunnerExtensionSpecification(x));
testProject.ReportNameFormat = reportNameFormat;
testProject.ReportDirectory = reportDirectory;
}
/// <summary>
/// Creates a host setup based on the package properties.
/// </summary>
/// <returns>The host setup.</returns>
public HostSetup CreateHostSetup()
{
var hostSetup = new HostSetup
{
DebuggerSetup = DebuggerSetup,
ShadowCopy = ShadowCopy,
ApplicationBaseDirectory = ApplicationBaseDirectory != null ? ApplicationBaseDirectory.FullName : null,
WorkingDirectory = WorkingDirectory != null ? WorkingDirectory.FullName : null,
RuntimeVersion = RuntimeVersion
};
GenericCollectionUtils.ForEach(Properties, x => hostSetup.AddProperty(x.Key, x.Value));
GenericCollectionUtils.ForEach(HintDirectories, x => hostSetup.AddHintDirectory(x.FullName));
return(hostSetup);
}
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);
}
}
/// <summary>
/// Initializes a test package with the contents of this structure.
/// </summary>
/// <param name="testPackage">The test package to populate.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="testPackage"/> is null.</exception>
public void InitializeTestPackage(TestPackage testPackage)
{
if (testPackage == null)
{
throw new ArgumentNullException("testPackage");
}
GenericCollectionUtils.ForEach(files, x => testPackage.AddFile(new FileInfo(x)));
GenericCollectionUtils.ForEach(hintDirectories, x => testPackage.AddHintDirectory(new DirectoryInfo(x)));
GenericCollectionUtils.ForEach(excludedFrameworkIds, x => testPackage.AddExcludedTestFrameworkId(x));
testPackage.ShadowCopy = ShadowCopy;
testPackage.DebuggerSetup = Debug ? new DebuggerSetup() : null;
testPackage.ApplicationBaseDirectory = ApplicationBaseDirectory != null ? new DirectoryInfo(ApplicationBaseDirectory) : null;
testPackage.WorkingDirectory = WorkingDirectory != null ? new DirectoryInfo(WorkingDirectory) : null;
testPackage.RuntimeVersion = RuntimeVersion;
GenericCollectionUtils.ForEach(Properties, x => testPackage.AddProperty(x.Key, x.Value));
}
private void Launch(bool doNoRun)
{
MarkupStreamWriter logStreamWriter = TestLog.Default;
var launcher = new TestLauncher();
launcher.TestProject.TestPackage = testPackage;
launcher.Logger = new MarkupStreamLogger(logStreamWriter);
launcher.TestExecutionOptions.FilterSet = new FilterSet <ITestDescriptor>(new OrFilter <ITestDescriptor>(filters));
launcher.TestProject.TestRunnerFactoryName = TestRunnerFactoryName;
string reportDirectory = SpecialPathPolicy.For <SampleRunner>().GetTempDirectory().FullName;
launcher.TestProject.ReportDirectory = reportDirectory;
launcher.TestProject.ReportNameFormat = "SampleRunnerReport";
launcher.ReportFormatterOptions.AddProperty(@"SaveAttachmentContents", @"false");
launcher.AddReportFormat(@"Text");
// Disabled because the Xml can get really big and causes problems if the sample runner is used frequently.
//launcher.AddReportFormat("Xml");
launcher.DoNotRun = doNoRun;
GenericCollectionUtils.ForEach(testRunnerOptions.Properties, x => launcher.TestRunnerOptions.AddProperty(x.Key, x.Value));
using (logStreamWriter.BeginSection("Log Output"))
result = launcher.Run();
using (logStreamWriter.BeginSection("Text Report"))
{
foreach (string reportPath in result.ReportDocumentPaths)
{
string extension = Path.GetExtension(reportPath);
if (extension == ".txt")
{
logStreamWriter.WriteLine(File.ReadAllText(reportPath));
}
else if (extension == ".xml")
{
logStreamWriter.Container.AttachXml(null, File.ReadAllText(reportPath));
}
File.Delete(reportPath);
}
}
}
/// <summary>
/// Applies the settings of another test package as an overlay on top of this one.
/// </summary>
/// <remarks>
/// <para>
/// Overrides scalar settings (such as <see cref="ApplicationBaseDirectory"/>) with those of
/// the overlay when they are specified (such as when <see cref="IsApplicationBaseDirectorySpecified" /> is true).
/// Merges aggregate settings (such as lists of files).
/// </para>
/// </remarks>
/// <param name="overlay">The test package to overlay on top of this one.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="overlay"/> is null.</exception>
public void ApplyOverlay(TestPackage overlay)
{
if (overlay == null)
{
throw new ArgumentNullException("overlay");
}
if (overlay.IsApplicationBaseDirectorySpecified)
{
ApplicationBaseDirectory = overlay.ApplicationBaseDirectory;
}
if (overlay.IsDebuggerSetupSpecified)
{
DebuggerSetup = overlay.DebuggerSetup;
}
if (overlay.IsRuntimeVersionSpecified)
{
RuntimeVersion = overlay.RuntimeVersion;
}
if (overlay.IsTestFrameworkOptionsSpecified)
{
TestFrameworkOptions = overlay.TestFrameworkOptions;
}
if (overlay.IsTestFrameworkFallbackModeSpecified)
{
TestFrameworkFallbackMode = overlay.TestFrameworkFallbackMode;
}
if (overlay.IsShadowCopySpecified)
{
ShadowCopy = overlay.ShadowCopy;
}
if (overlay.IsWorkingDirectorySpecified)
{
WorkingDirectory = overlay.WorkingDirectory;
}
GenericCollectionUtils.ForEach(overlay.Files, x => AddFile(x));
GenericCollectionUtils.ForEach(overlay.HintDirectories, x => AddHintDirectory(x));
GenericCollectionUtils.ForEach(overlay.ExcludedTestFrameworkIds, x => AddExcludedTestFrameworkId(x));
GenericCollectionUtils.ForEach(overlay.Properties, x => properties[x.Key] = x.Value);
}
/// <summary>
/// Creates a local host.
/// </summary>
/// <param name="hostSetup">The host setup.</param>
/// <param name="logger">The logger for host message output.</param>
/// <param name="debuggerManager">The debugger manager.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="hostSetup"/>, <paramref name="logger"/>
/// or <paramref name="debuggerManager"/> is null.</exception>
public LocalHost(HostSetup hostSetup, ILogger logger, IDebuggerManager debuggerManager)
: base(hostSetup, logger)
{
if (debuggerManager == null)
{
throw new ArgumentNullException("debuggerManager");
}
this.debuggerManager = debuggerManager;
if (!string.IsNullOrEmpty(hostSetup.WorkingDirectory))
{
currentDirectorySwitcher = new CurrentDirectorySwitcher(hostSetup.WorkingDirectory);
}
if (hostSetup.HintDirectories.Count != 0)
{
assemblyLoader = new DefaultAssemblyLoader();
GenericCollectionUtils.ForEach(hostSetup.HintDirectories, assemblyLoader.AddHintDirectory);
}
}
/// <summary>
/// Applies the settings of another test project as an overlay on top of this one.
/// </summary>
/// <remarks>
/// <para>
/// Overrides scalar settings (such as <see cref="ReportNameFormat"/>) with those of
/// the overlay when they are specified (such as when <see cref="IsReportNameFormatSpecified" /> is true).
/// Merges aggregate settings (such as lists of files).
/// </para>
/// </remarks>
/// <param name="overlay">The test project to overlay on top of this one.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="overlay"/> is null.</exception>
public void ApplyOverlay(TestProject overlay)
{
if (overlay == null)
{
throw new ArgumentNullException("overlay");
}
if (overlay.IsReportNameFormatSpecified)
{
ReportNameFormat = overlay.ReportNameFormat;
}
if (overlay.IsReportDirectorySpecified)
{
ReportDirectory = overlay.ReportDirectory;
}
if (overlay.IsTestRunnerFactoryNameSpecified)
{
TestRunnerFactoryName = overlay.TestRunnerFactoryName;
}
GenericCollectionUtils.ForEach(overlay.TestFilters, x => AddTestFilter(x.Copy()));
GenericCollectionUtils.ForEach(overlay.TestRunnerExtensions, AddTestRunnerExtension);
GenericCollectionUtils.ForEach(overlay.TestRunnerExtensionSpecifications, AddTestRunnerExtensionSpecification);
TestPackage.ApplyOverlay(overlay.TestPackage);
}
/// <summary>
/// Clears the list of test parameters.
/// </summary>
public void ClearParameters()
{
GenericCollectionUtils.ForEach(Parameters, x => x.Owner = null);
parameters = null;
}
/// <summary>
/// Clears the list of children.
/// </summary>
public void ClearChildren()
{
GenericCollectionUtils.ForEach(Children, x => x.Parent = null);
children = null;
}
/// <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));
}
}
/// <inheritdoc />
public Report Run(TestPackage testPackage, TestExplorationOptions testExplorationOptions, TestExecutionOptions testExecutionOptions, IProgressMonitor progressMonitor)
{
if (testPackage == null)
{
throw new ArgumentNullException("testPackageConfig");
}
if (testExplorationOptions == null)
{
throw new ArgumentNullException("testExplorationOptions");
}
if (testExecutionOptions == null)
{
throw new ArgumentNullException("testExecutionOptions");
}
if (progressMonitor == null)
{
throw new ArgumentNullException("progressMonitor");
}
ThrowIfDisposed();
if (state != State.Initialized)
{
throw new InvalidOperationException("The test runner must be initialized before this operation is performed.");
}
testPackage = testPackage.Copy();
testExplorationOptions = testExplorationOptions.Copy();
testExecutionOptions = testExecutionOptions.Copy();
GenericCollectionUtils.ForEach(testRunnerOptions.Properties, x => testPackage.AddProperty(x.Key, x.Value));
using (progressMonitor.BeginTask("Running the tests.", 10))
{
Stopwatch stopwatch = Stopwatch.StartNew();
Report report = new Report()
{
TestPackage = new TestPackageData(testPackage),
TestModel = new TestModelData(),
TestPackageRun = new TestPackageRun()
{
StartTime = DateTime.Now
}
};
var reportLockBox = new LockBox <Report>(report);
eventDispatcher.NotifyRunStarted(new RunStartedEventArgs(testPackage, testExplorationOptions,
testExecutionOptions, reportLockBox));
bool success;
using (Listener listener = new Listener(eventDispatcher, tappedLogger, reportLockBox))
{
try
{
ITestDriver testDriver = testFrameworkManager.GetTestDriver(
testPackage.CreateTestFrameworkSelector(), tappedLogger);
using (testIsolationContext.BeginBatch(progressMonitor.SetStatus))
{
testDriver.Run(testIsolationContext, testPackage, testExplorationOptions,
testExecutionOptions, listener, progressMonitor.CreateSubProgressMonitor(10));
}
success = true;
}
catch (Exception ex)
{
success = false;
tappedLogger.Log(LogSeverity.Error,
"A fatal exception occurred while running tests. Possible causes include invalid test runner parameters and stack overflows.",
ex);
report.TestModel.Annotations.Add(new AnnotationData(AnnotationType.Error,
CodeLocation.Unknown, CodeReference.Unknown,
"A fatal exception occurred while running tests. See log for details.", null));
}
finally
{
report.TestPackageRun.EndTime = DateTime.Now;
report.TestPackageRun.Statistics.Duration = stopwatch.Elapsed.TotalSeconds;
}
}
eventDispatcher.NotifyRunFinished(new RunFinishedEventArgs(success, report));
return(report);
}
}
/// <inheritdoc />
protected override int RunImpl(string[] args)
{
ShowBanner();
InstallCancelHandler();
if (!ParseArguments(args) || Arguments.CommandAndArguments.Length == 0)
{
ShowHelp();
return(Arguments.Help ? 0 : 1);
}
ILogger logger = CreateLogger();
IProgressMonitorProvider progressMonitorProvider = Arguments.NoProgress
? (IProgressMonitorProvider)NullProgressMonitorProvider.Instance
: new RichConsoleProgressMonitorProvider(Console);
string commandName = Arguments.CommandAndArguments[0];
string[] commandRawArguments = new string[Arguments.CommandAndArguments.Length - 1];
Array.Copy(Arguments.CommandAndArguments, 1, commandRawArguments, 0, commandRawArguments.Length);
IUtilityCommand command = GetSpecialCommand(commandName);
bool isSpecialCommand = command != null;
var runtimeSetup = new RuntimeSetup();
GenericCollectionUtils.ForEach(Arguments.PluginDirectories, x => runtimeSetup.AddPluginDirectory(x));
using (isSpecialCommand ? null : RuntimeBootstrap.Initialize(runtimeSetup, logger))
{
if (command == null)
{
var commandManager = RuntimeAccessor.ServiceLocator.Resolve <IUtilityCommandManager>();
command = commandManager.GetCommand(commandName);
if (command == null)
{
ShowErrorMessage(string.Format("Unrecognized utility command name: '{0}'.", commandName));
ShowHelp();
return(1);
}
}
Type commandArgumentsClass = command.GetArgumentClass();
var commandArgumentParser = new CommandLineArgumentParser(commandArgumentsClass, null);
if (Arguments.Help)
{
ShowHelpForParticularCommand(commandName, commandArgumentParser);
return(0);
}
object commandArguments = Activator.CreateInstance(commandArgumentsClass);
if (!commandArgumentParser.Parse(commandRawArguments, commandArguments, ShowErrorMessage) || !command.ValidateArguments(commandArguments, ShowErrorMessage))
{
ShowHelpForParticularCommand(commandName, commandArgumentParser);
return(1);
}
var commandContext = new UtilityCommandContext(commandArguments, Console, logger, progressMonitorProvider, Arguments.Verbosity);
return(command.Execute(commandContext));
}
}
internal static void ConfigureLauncherFromArguments(TestLauncher launcher, EchoArguments arguments)
{
launcher.RuntimeSetup = new RuntimeSetup();
GenericCollectionUtils.ForEach(arguments.PluginDirectories, x => launcher.RuntimeSetup.AddPluginDirectory(x));
if (arguments.ShadowCopy.HasValue)
{
launcher.TestProject.TestPackage.ShadowCopy = arguments.ShadowCopy.Value;
}
if (arguments.Debug.HasValue && arguments.Debug.Value)
{
launcher.TestProject.TestPackage.DebuggerSetup = new DebuggerSetup();
}
if (arguments.ApplicationBaseDirectory != null)
{
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(arguments.ApplicationBaseDirectory);
}
if (arguments.WorkingDirectory != null)
{
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(arguments.WorkingDirectory);
}
if (arguments.RuntimeVersion != null)
{
launcher.TestProject.TestPackage.RuntimeVersion = arguments.RuntimeVersion;
}
GenericCollectionUtils.ForEach(arguments.Files, launcher.AddFilePattern);
foreach (string hintDirectory in arguments.HintDirectories)
{
launcher.TestProject.TestPackage.AddHintDirectory(new DirectoryInfo(hintDirectory));
}
if (arguments.ReportDirectory != null)
{
launcher.TestProject.ReportDirectory = arguments.ReportDirectory;
}
if (arguments.ReportNameFormat != null)
{
launcher.TestProject.ReportNameFormat = arguments.ReportNameFormat;
}
launcher.TestProject.ReportArchive = ReportArchive.Parse(arguments.ReportArchive);
GenericCollectionUtils.ForEach(arguments.ReportTypes, launcher.AddReportFormat);
if (arguments.RunnerType != null)
{
launcher.TestProject.TestRunnerFactoryName = arguments.RunnerType;
}
GenericCollectionUtils.ForEach(arguments.RunnerExtensions, x => launcher.TestProject.AddTestRunnerExtensionSpecification(x));
foreach (string option in arguments.ReportFormatterProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.ReportFormatterOptions.AddProperty(pair.Key, pair.Value);
}
foreach (string option in arguments.RunnerProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.TestRunnerOptions.AddProperty(pair.Key, pair.Value);
}
launcher.DoNotRun = arguments.DoNotRun;
launcher.IgnoreAnnotations = arguments.IgnoreAnnotations;
if (!String.IsNullOrEmpty(arguments.Filter))
{
launcher.TestExecutionOptions.FilterSet = FilterUtils.ParseTestFilterSet(arguments.Filter);
}
launcher.EchoResults = !arguments.NoEchoResults;
launcher.ShowReports = arguments.ShowReports;
if (arguments.RunTimeLimitInSeconds >= 0)
{
launcher.RunTimeLimit = TimeSpan.FromSeconds(arguments.RunTimeLimitInSeconds);
}
}
internal void InternalExecute()
{
// We don't catch exceptions here because NAnt takes care of that job,
// and decides whether to let them through based on the value of the
// FailOnError
var logger = CreateLogger();
DisplayVersion();
var launcher = new TestLauncher();
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = GetFilterSet();
launcher.ShowReports = ShowReports;
launcher.DoNotRun = DoNotRun;
launcher.IgnoreAnnotations = IgnoreAnnotations;
launcher.EchoResults = EchoResults;
launcher.RunTimeLimit = runTimeLimit;
if (RunnerType != null)
{
launcher.TestProject.TestRunnerFactoryName = RunnerType;
}
if (RunnerExtensions != null)
{
foreach (Argument arg in RunnerExtensions)
{
launcher.TestProject.AddTestRunnerExtensionSpecification(arg.Value);
}
}
launcher.RuntimeSetup = new RuntimeSetup();
// Set the installation path explicitly to the path of the NAnt task assembly
// since otherwise we will look at the path of NAnt.exe.
launcher.RuntimeSetup.RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation(typeof(GallioTask).Assembly));
if (ApplicationBaseDirectory != null)
{
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(ApplicationBaseDirectory);
}
if (WorkingDirectory != null)
{
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(WorkingDirectory);
}
if (ShadowCopy.HasValue)
{
launcher.TestProject.TestPackage.ShadowCopy = ShadowCopy.Value;
}
if (Debug.HasValue && Debug.Value)
{
launcher.TestProject.TestPackage.DebuggerSetup = new DebuggerSetup();
}
if (RuntimeVersion != null)
{
launcher.TestProject.TestPackage.RuntimeVersion = RuntimeVersion;
}
foreach (Argument option in ReportFormatterProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option.Value);
launcher.ReportFormatterOptions.AddProperty(pair.Key, pair.Value);
}
foreach (Argument option in RunnerProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option.Value);
launcher.TestRunnerOptions.AddProperty(pair.Key, pair.Value);
}
AddAssemblies(launcher);
AddHintDirectories(launcher);
AddPluginDirectories(launcher);
if (ReportDirectory != null)
{
launcher.TestProject.ReportDirectory = ReportDirectory;
}
if (ReportNameFormat != null)
{
launcher.TestProject.ReportNameFormat = ReportNameFormat;
}
if (ReportArchive != null)
{
launcher.TestProject.ReportArchive = Runner.Reports.ReportArchive.Parse(ReportArchive);
}
if (ReportTypes != null)
{
string[] typeNames = ReportTypes.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
GenericCollectionUtils.ForEach(typeNames, launcher.AddReportFormat);
}
TestLauncherResult result = RunLauncher(launcher);
SetResultProperty(result.ResultCode);
PopulateStatistics(result);
if (!FailOnError)
{
return;
}
if (result.ResultCode != ResultCode.Success && result.ResultCode != ResultCode.NoTests)
{
// The only way to make the task fail is to throw an exception
throw new BuildException(Resources.TestExecutionFailed);
}
}
internal bool InternalExecute()
{
DisplayVersion();
var logger = new FilteredLogger(new TaskLogger(Log), verbosity);
var launcher = new TestLauncher();
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = GetFilterSet();
launcher.ShowReports = ShowReports;
launcher.DoNotRun = DoNotRun;
launcher.IgnoreAnnotations = IgnoreAnnotations;
launcher.RunTimeLimit = runTimeLimit;
launcher.RuntimeSetup = new RuntimeSetup();
// Set the installation path explicitly to the path of the MSBuild task assembly
// since otherwise we will look at the path of MSBuild.exe.
launcher.RuntimeSetup.RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation(typeof(Gallio).Assembly));
if (EchoResults)
{
launcher.TestProject.AddTestRunnerExtension(new TaskLogExtension(Log));
}
if (ApplicationBaseDirectory != null)
{
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(ApplicationBaseDirectory.ItemSpec);
}
if (WorkingDirectory != null)
{
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(WorkingDirectory.ItemSpec);
}
launcher.TestProject.TestPackage.ShadowCopy = ShadowCopy;
if (Debug)
{
launcher.TestProject.TestPackage.DebuggerSetup = new DebuggerSetup();
}
if (RuntimeVersion != null)
{
launcher.TestProject.TestPackage.RuntimeVersion = RuntimeVersion;
}
foreach (string option in ReportFormatterProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.ReportFormatterOptions.AddProperty(pair.Key, pair.Value);
}
foreach (string option in RunnerProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.TestRunnerOptions.AddProperty(pair.Key, pair.Value);
}
ForEachItemSpec(Files, launcher.AddFilePattern);
ForEachItemSpec(HintDirectories, x => launcher.TestProject.TestPackage.AddHintDirectory(new DirectoryInfo(x)));
ForEachItemSpec(PluginDirectories, x => launcher.RuntimeSetup.AddPluginDirectory(x));
if (ReportDirectory != null)
{
launcher.TestProject.ReportDirectory = ReportDirectory.ItemSpec;
}
if (ReportNameFormat != null)
{
launcher.TestProject.ReportNameFormat = ReportNameFormat;
}
if (ReportTypes != null)
{
GenericCollectionUtils.ForEach(ReportTypes, launcher.AddReportFormat);
}
if (ReportArchive != null)
{
launcher.TestProject.ReportArchive = Runner.Reports.ReportArchive.Parse(ReportArchive);
}
if (RunnerType != null)
{
launcher.TestProject.TestRunnerFactoryName = RunnerType;
}
if (RunnerExtensions != null)
{
GenericCollectionUtils.ForEach(RunnerExtensions, x => launcher.TestProject.AddTestRunnerExtensionSpecification(x));
}
TestLauncherResult result = RunLauncher(launcher);
ExitCode = result.ResultCode;
LogResultSummary(logger, result);
PopulateStatistics(result);
return(ExitCode == ResultCode.Success ||
ExitCode == ResultCode.NoTests ||
IgnoreFailures);
}
internal TestLauncherResult Execute()
{
var launcher = new TestLauncher
{
Logger = Logger,
ProgressMonitorProvider = ProgressMonitorProvider,
TestExecutionOptions = { FilterSet = GetFilterSet() },
ShowReports = ShowReports.IsPresent,
DoNotRun = DoNotRun.IsPresent,
IgnoreAnnotations = IgnoreAnnotations.IsPresent,
EchoResults = !NoEchoResults.IsPresent,
RunTimeLimit = runTimeLimit
};
if (RunnerType != null)
{
launcher.TestProject.TestRunnerFactoryName = RunnerType;
}
if (RunnerExtensions != null)
{
GenericCollectionUtils.ForEach(RunnerExtensions, x => launcher.TestProject.AddTestRunnerExtensionSpecification(x));
}
launcher.RuntimeSetup = new RuntimeSetup();
// Set the installation path explicitly to the path of the Gallio cmdlet task assembly
// since otherwise we will look at the path of PowerShell.exe.
launcher.RuntimeSetup.RuntimePath = Path.GetDirectoryName(AssemblyUtils.GetFriendlyAssemblyLocation(typeof(RunGallioCommand).Assembly));
if (ApplicationBaseDirectory != null)
{
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(ApplicationBaseDirectory);
}
if (WorkingDirectory != null)
{
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(WorkingDirectory);
}
if (ShadowCopy.HasValue)
{
launcher.TestProject.TestPackage.ShadowCopy = ShadowCopy.Value.IsPresent;
}
if (DebugTests.HasValue && DebugTests.Value.IsPresent)
{
launcher.TestProject.TestPackage.DebuggerSetup = new DebuggerSetup();
}
if (RuntimeVersion != null)
{
launcher.TestProject.TestPackage.RuntimeVersion = RuntimeVersion;
}
foreach (string option in ReportFormatterProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.ReportFormatterOptions.AddProperty(pair.Key, pair.Value);
}
foreach (string option in RunnerProperties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
launcher.TestRunnerOptions.AddProperty(pair.Key, pair.Value);
}
ForEachItem(Files, launcher.AddFilePattern);
ForEachItem(HintDirectories, x => launcher.TestProject.TestPackage.AddHintDirectory(new DirectoryInfo(x)));
ForEachItem(PluginDirectories, x => launcher.RuntimeSetup.AddPluginDirectory(x));
if (ReportDirectory != null)
{
launcher.TestProject.ReportDirectory = ReportDirectory;
}
if (ReportNameFormat != null)
{
launcher.TestProject.ReportNameFormat = ReportNameFormat;
}
if (ReportTypes != null)
{
GenericCollectionUtils.ForEach(ReportTypes, launcher.AddReportFormat);
}
launcher.TestProject.ReportArchive = Runner.Reports.ReportArchive.Parse(ReportArchive);
TestLauncherResult result = RunLauncher(launcher);
return(result);
}
