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 void Update()
{
// Do this work in the background to avoid a possible deadlock acquiring the report lock
// on the UI thread.
taskManager.ClearQueue(QueueId);
taskManager.QueueTask(QueueId, new DelegateCommand((pm => testController.ReadReport(report =>
{
TestModelData = report.TestModel;
var testStepRuns = new List <TestStepRun>();
if (report.TestPackageRun != null)
{
foreach (var testStepRun in report.TestPackageRun.AllTestStepRuns)
{
if (RelevantStep(testStepRun))
{
testStepRuns.Add(testStepRun);
}
}
}
EventHandlerPolicy.SafeInvoke(ExecutionLogUpdated, this,
new ExecutionLogUpdatedEventArgs(testStepRuns));
}))));
}
public ProgressController(ITaskManager taskManager, IOptionsController optionsController)
{
this.taskManager = taskManager;
timer.Interval = TimeSpan.FromSeconds(2).TotalMilliseconds;
timer.Elapsed += (sender, e) =>
{
if (!optionsController.ShowProgressDialogs)
{
return;
}
// HACK: we don't want to display the progress dialog when running tests
// but relying on the task name is not ideal
if (ProgressMonitor.TaskName == Resources.RunTestsCommand_Running_tests)
{
return;
}
EventHandlerPolicy.SafeInvoke(DisplayProgressDialog, this,
new ProgressEvent(ProgressMonitor));
};
Status = new Observable <string>();
TotalWork = new Observable <double>();
CompletedWork = new Observable <double>();
}
/// <summary>
/// Sets the runtime instance.
/// </summary>
/// <remarks>
/// <para>
/// This method should only be used by applications that host Gallio
/// and not generally by client code.
/// </para>
/// </remarks>
/// <param name="runtime">The runtime instance, or null if none.</param>
public static void SetRuntime(IRuntime runtime)
{
EventHandler instanceChangedHandlers = InstanceChanged;
instance = runtime;
EventHandlerPolicy.SafeInvoke(instanceChangedHandlers, null, EventArgs.Empty);
}
/// <inheritdoc />
protected override void Dispose(bool disposing)
{
if (disposing)
{
EventHandlerPolicy.SafeInvoke(Disposed, this, EventArgs.Empty);
}
base.Dispose(disposing);
}
private void LogErrorData(object sender, DataReceivedEventArgs e)
{
if (captureConsoleError && e.Data != null)
{
consoleErrorCaptureWriter.WriteLine(e.Data);
}
EventHandlerPolicy.SafeInvoke(ConsoleErrorDataReceived, this, e);
}
private void HandleTaskAborted(object sender, TaskEventArgs e)
{
EventHandler <TaskEventArgs> cachedChain;
lock (this)
cachedChain = aborted;
EventHandlerPolicy.SafeInvoke(cachedChain, this, e);
}
/// <summary>
/// Aborts the processing of the command.
/// </summary>
protected override void StopProcessing()
{
EventHandler handler;
lock (this)
handler = stopRequested;
EventHandlerPolicy.SafeInvoke(handler, this, EventArgs.Empty);
}
private void NotifyFinishing(object sender, EventArgs e)
{
try
{
EventHandlerPolicy.SafeInvoke(finishingHandlers, this, EventArgs.Empty);
}
catch (Exception ex)
{
LogWriter.Failures.WriteException(ex, "An exception during Finishing event processing.");
}
}
private void Notify(ref EventHandler <TaskEventArgs> chain)
{
EventHandler <TaskEventArgs> cachedChain;
lock (this)
{
cachedChain = chain;
chain = Signal;
}
EventHandlerPolicy.SafeInvoke(cachedChain, this, new TaskEventArgs(this));
}
private void HandleTaskStarted(object sender, TaskEventArgs e)
{
EventHandler <TaskEventArgs> cachedChain;
lock (this)
{
activeTasks.Add(e.Task);
cachedChain = started;
}
EventHandlerPolicy.SafeInvoke(cachedChain, this, e);
}
public ProgressController(ITaskManager taskManager)
{
this.taskManager = taskManager;
timer.Interval = TimeSpan.FromSeconds(2).TotalMilliseconds;
timer.Elapsed += (sender, e) => EventHandlerPolicy.SafeInvoke(DisplayProgressDialog,
this, new ProgressEvent(ProgressMonitor));
Status = new Observable <string>();
TotalWork = new Observable <double>();
CompletedWork = new Observable <double>();
}
public void Dispatch(LogSeverity severity, string message, ExceptionData exceptionData)
{
EventHandlerPolicy.SafeInvoke(LogMessage, this, new LogEntrySubmittedEventArgs(severity, message, exceptionData));
foreach (ILogger logger in Listeners)
{
try
{
logger.Log(severity, message, exceptionData);
}
catch (Exception ex)
{
UnhandledExceptionPolicy.Report(
"An exception occurred while dispatching a message to a log listener.", ex);
}
}
}
/// <summary>
/// Sets the state of the host to disconnected and notifies clients.
/// </summary>
protected void NotifyDisconnected()
{
EventHandler cachedDisconnectedHandlers;
lock (syncRoot)
{
if (hostService == null)
{
return;
}
cachedDisconnectedHandlers = disconnectedHandlers;
disconnectedHandlers = null;
hostService = null;
}
EventHandlerPolicy.SafeInvoke(cachedDisconnectedHandlers, this, EventArgs.Empty);
}
private void SetupParentDirectoryWatcher(string reportDirectory, string parentDirectory, string reportNameFormat)
{
var reportDirectoryWatcher = new FileSystemWatcher
{
NotifyFilter = NotifyFilters.DirectoryName,
Path = parentDirectory,
EnableRaisingEvents = true
};
reportDirectoryWatcher.Created += (s, e) =>
{
if (e.FullPath != reportDirectory)
{
return;
}
EventHandlerPolicy.SafeInvoke(ReportDirectoryCreated, this, EventArgs.Empty);
SetupDirectoryWatcher(reportDirectory, reportNameFormat);
};
reportDirectoryWatcher.Deleted += (s, e) =>
{
if (e.FullPath == reportDirectory)
{
EventHandlerPolicy.SafeInvoke(ReportDirectoryDeleted, this, EventArgs.Empty);
}
};
reportDirectoryWatcher.Renamed += (s, e) =>
{
if (e.OldFullPath == reportDirectory)
{
EventHandlerPolicy.SafeInvoke(ReportDirectoryDeleted, this, EventArgs.Empty);
}
else if (e.FullPath == reportDirectory)
{
EventHandlerPolicy.SafeInvoke(ReportDirectoryCreated, this, EventArgs.Empty);
}
};
}
private void Abort(TestOutcome outcome, string message, bool throwIfDisposed)
{
EventHandler cachedHandler;
ThreadAbortScope[] cachedScopes;
lock (syncRoot)
{
if (throwIfDisposed)
{
ThrowIfDisposed();
}
if (abortOutcome.HasValue)
{
return;
}
abortOutcome = outcome;
abortMessage = message;
cachedScopes = scopesAndThreads != null
? GenericCollectionUtils.ConvertAllToArray(scopesAndThreads, pair => pair.First)
: null;
scopesAndThreads = null;
cachedHandler = aborted;
aborted = null;
}
if (cachedScopes != null)
{
foreach (ThreadAbortScope scope in cachedScopes)
{
scope.Abort();
}
}
EventHandlerPolicy.SafeInvoke(cachedHandler, this, EventArgs.Empty);
}
/// <summary>
/// Notifies that the task has actually been canceled.
/// </summary>
/// <remarks>
/// <para>
/// If this is the first time <see cref="NotifyCanceled" /> has been called,
/// sets <see cref="IsCanceled" /> to true and fires the <see cref="Canceled" /> event.
/// Otherwise does nothing.
/// </para>
/// <para>
/// This is the ONLY method of the progress monitor that is allowed to
/// be called concurrently from multiple threads. It needs to be this
/// way so that cancelation can be initiated by either participant in the
/// progress monitoring dialog.
/// </para>
/// </remarks>
/// <returns>True if cancelation has just occurred, false if no
/// state change was performed.</returns>
protected bool NotifyCanceled()
{
EventHandler currentCanceledHandler;
lock (this)
{
if (isCanceled)
{
return(false);
}
isCanceled = true;
currentCanceledHandler = canceledHandler;
// We will never call these handlers again so there's no point
// keeping them around anymore.
canceledHandler = null;
}
EventHandlerPolicy.SafeInvoke(currentCanceledHandler, this, EventArgs.Empty);
return(true);
}
private void SetupDirectoryWatcher(string reportDirectory, string reportNameFormat)
{
var regex = new Regex("{.}");
reportNameFormat = regex.Replace(reportNameFormat, "*") + "*.xml";
var reportDirectoryWatcher = new FileSystemWatcher
{
Filter = reportNameFormat,
NotifyFilter = NotifyFilters.FileName,
Path = reportDirectory,
EnableRaisingEvents = true
};
reportDirectoryWatcher.Created += (s, e) => EventHandlerPolicy.SafeInvoke(ReportCreated,
this, new ReportCreatedEventArgs(e.FullPath));
reportDirectoryWatcher.Deleted += (s, e) => EventHandlerPolicy.SafeInvoke(ReportDeleted,
this, new ReportDeletedEventArgs(e.FullPath));
reportDirectoryWatcher.Renamed += (s, e) =>
{
// if the new filename is a valid report format, then rename the node
if (new Regex(reportNameFormat.Replace("*", ".*")).Match(e.FullPath).Success)
{
EventHandlerPolicy.SafeInvoke(ReportRenamed, this,
new ReportRenamedEventArgs(e.OldFullPath, e.FullPath));
}
else
{
// otherwise delete it
EventHandlerPolicy.SafeInvoke(ReportDeleted, this,
new ReportDeletedEventArgs(e.OldFullPath));
}
};
}
private void HandleTaskTerminated(object sender, TaskEventArgs e)
{
try
{
EventHandler <TaskEventArgs> cachedChain;
lock (this)
{
cachedChain = terminated;
}
EventHandlerPolicy.SafeInvoke(cachedChain, this, e);
}
finally
{
// Do this last to ensure that all event handlers have executed
// before we remove the task from the list. This helps to ensure
// that JoinAll fully synchronizes with the task and with any
// final event-based processing that needs to occur.
lock (this)
{
activeTasks.Remove(e.Task);
}
}
}
public void Handle(ExploreFinished @event)
{
EventHandlerPolicy.SafeInvoke(RestoreState, this,
EventArgs.Empty);
testExplorerModel.CanEditTree.Value = true;
}
public void ViewSourceCode(CodeLocation codeLocation)
{
// fire event for view
EventHandlerPolicy.SafeInvoke(ShowSourceCode, this,
new ShowSourceCodeEventArgs(codeLocation));
}
/// <summary>
/// Dispatches the <see cref="TestStepLogStreamEmbed" /> event.
/// </summary>
/// <param name="e">The event arguments.</param>
public void NotifyTestStepLogStreamEmbed(TestStepLogStreamEmbedEventArgs e)
{
EventHandlerPolicy.SafeInvoke(TestStepLogStreamEmbed, this, e);
}
/// <summary>
/// Dispatches the <see cref="TestStepLogStreamEndBlock" /> event.
/// </summary>
/// <param name="e">The event arguments.</param>
public void NotifyTestStepLogStreamEndBlock(TestStepLogStreamEndBlockEventArgs e)
{
EventHandlerPolicy.SafeInvoke(TestStepLogStreamEndBlock, this, e);
}
private TestResult FinishStep(TestOutcome outcome, TimeSpan?actualDuration, bool isDisposing)
{
EventHandler cachedFinishingHandlers;
lock (syncRoot)
{
if (!IsRunning)
{
if (isDisposing)
{
return(result ?? new TestResult(TestOutcome.Error));
}
throw new InvalidOperationException("Cannot finish a step unless the test step is running.");
}
this.outcome = outcome;
executionStatus = StatusFinishing;
LifecyclePhase = LifecyclePhases.Finishing;
cachedFinishingHandlers = finishingHandlers;
finishingHandlers = null;
}
// Note: We no longer need to hold the lock because none of the state used from here on can change
// since the status is now StatusFinishing.
try
{
if (parent != null)
{
parent.Finishing -= HandleParentFinishedBeforeThisContext;
}
using (Enter())
EventHandlerPolicy.SafeInvoke(cachedFinishingHandlers, this, EventArgs.Empty);
if (isDisposing)
{
logWriter.Failures.Write("The test step was orphaned by the test runner!\n");
}
logWriter.Close();
result = new TestResult(outcome)
{
AssertCount = assertCount,
Duration = actualDuration.GetValueOrDefault(stopwatch.Elapsed)
};
MessageSink.Publish(new TestStepFinishedMessage()
{
StepId = testStep.Id,
Result = result
});
if (contextCookie != null)
{
if (!isDisposing)
{
contextCookie.Dispose();
}
contextCookie = null;
}
return(result);
}
catch (Exception ex)
{
UnhandledExceptionPolicy.Report("An unhandled exception occurred while finishing a test step.", ex);
return(new TestResult(TestOutcome.Error));
}
finally
{
lock (syncRoot)
executionStatus = StatusFinished;
}
}
/// <summary>
/// Called when a new progress monitor is created.
/// </summary>
protected virtual void OnSubProgressMonitorCreated(ObservableProgressMonitor subProgressMonitor)
{
EventHandlerPolicy.SafeInvoke(SubProgressMonitorCreated, this, new SubProgressMonitorCreatedEventArgs(subProgressMonitor));
}
/// <summary>
/// Called when a state change occurs.
/// </summary>
protected virtual void OnChange()
{
EventHandlerPolicy.SafeInvoke(Changed, this, EventArgs.Empty);
}
/// <summary>
/// Called when <see cref="Done" /> performs its updates.
/// </summary>
protected virtual void OnDone()
{
OnChange();
EventHandlerPolicy.SafeInvoke(TaskFinished, this, EventArgs.Empty);
}
/// <summary>
/// Called after <see cref="BeginTask" /> performs its updates.
/// </summary>
/// <param name="taskName">The task name.</param>
/// <param name="totalWorkUnits">The total number of work units.</param>
protected virtual void OnBeginTask(string taskName, double totalWorkUnits)
{
EventHandlerPolicy.SafeInvoke(TaskStarting, this, EventArgs.Empty);
OnChange();
}
public void Handle(RunStarted @event)
{
TestModelData = null;
EventHandlerPolicy.SafeInvoke(ExecutionLogReset,
true, System.EventArgs.Empty);
}
private void TriggerStateSave()
{
EventHandlerPolicy.SafeInvoke(SaveState, this, EventArgs.Empty);
}