public static ProgressObserver StartObserving(IServiceProvider serviceProvider, IProgressEvents progressEvents, IProgressVisualizer visualizer, ProgressControllerViewModel state)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (progressEvents == null)
{
throw new ArgumentNullException(nameof(progressEvents));
}
if (visualizer == null)
{
throw new ArgumentNullException(nameof(visualizer));
}
CheckSupportedProgressEvents(progressEvents);
ProgressObserver observer = CreateAndConfigureInstance(serviceProvider, visualizer, progressEvents, null, state);
Debug.Assert(observer != null, "Failed to create observer on the UI thread");
return(observer);
}
private static ProgressObserver CreateAndConfigureInstance(IServiceProvider serviceProvider, IProgressVisualizer visualizer, IProgressEvents progressEvents, ICommand cancelCommand, ProgressControllerViewModel state)
{
return(VsThreadingHelper.RunInline(serviceProvider, VsTaskRunContext.UIThreadNormalPriority, () =>
{
ProgressObserver returnValue = new ProgressObserver(serviceProvider, visualizer, progressEvents, state);
returnValue.CancelCommand = cancelCommand;
return returnValue;
}, null));
}
public void TestCleanup()
{
if (this.testSubject != null)
{
((IDisposable)this.testSubject).Dispose();
this.testSubject = null;
}
this.testVisualizer = null;
this.testServiceProvider = null;
this.progressEvents = null;
this.threadService = null;
this.testController = null;
}
/// <summary>
/// Stops the specified <see cref="ProgressObserver"/> from observing.
/// The method is thread safe.
/// </summary>
/// <param name="observer">An existing <see cref="ProgressObserver"/> to stop observing with</param>
public static void StopObserving(ProgressObserver observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
if (observer.disposed)
{
return;
}
VsThreadingHelper.RunInline(observer.serviceProvider, VsTaskRunContext.UIThreadNormalPriority, () => ((IDisposable)observer).Dispose());
}
public static ProgressObserver StartObserving(IProgressController controller, IProgressVisualizer visualizer, ProgressControllerViewModel state)
{
if (controller == null)
{
throw new ArgumentNullException(nameof(controller));
}
if (visualizer == null)
{
throw new ArgumentNullException(nameof(visualizer));
}
CheckSupportedController(controller);
ProgressObserver observer = CreateAndConfigureInstance((IServiceProvider)controller, visualizer, controller.Events, new RelayCommand((s) => controller.TryAbort()), state);
Debug.Assert(observer != null, "Failed to create observer on the UI thread");
return(observer);
}
private static ProgressObserver CreateAndConfigureInstance(IServiceProvider serviceProvider, IProgressVisualizer visualizer, IProgressEvents progressEvents, ICommand cancelCommand, ProgressControllerViewModel state)
{
return VsThreadingHelper.RunInline(serviceProvider, VsTaskRunContext.UIThreadNormalPriority, () =>
{
ProgressObserver returnValue = new ProgressObserver(serviceProvider, visualizer, progressEvents, state);
returnValue.CancelCommand = cancelCommand;
return returnValue;
}, null);
}
/// <summary>
/// Stops the specified <see cref="ProgressObserver"/> from observing.
/// The method is thread safe.
/// </summary>
/// <param name="observer">An existing <see cref="ProgressObserver"/> to stop observing with</param>
public static void StopObserving(ProgressObserver observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
if (observer.disposed)
{
return;
}
VsThreadingHelper.RunInline(observer.serviceProvider, VsTaskRunContext.UIThreadNormalPriority, () => ((IDisposable)observer).Dispose());
}
public void ProgressObserver_StartAndStopObserving_OnForegroundThread()
{
this.threadService.SetCurrentThreadIsUIThread(true);
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
Assert.AreSame(this.testVisualizer, this.testSubject.Visualizer, "Unexpected visualizer");
Assert.IsNotNull(this.testSubject, "Failed to create observer on a foreground thread");
Assert.IsFalse(this.testSubject.IsDisposed, "Not expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
Assert.AreSame(this.testVisualizer, this.testSubject.Visualizer, "Unexpected visualizer");
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to be disposed");
}
public ExecutionVerifier(IProgressVisualizer visualizer, ProgressObserver testSubject)
{
Assert.IsNotNull(visualizer != null, "IProgressVisualizer is expected");
Assert.IsNotNull(testSubject != null, "ProgressObserver is expected");
this.visualizer = visualizer;
this.testSubject = testSubject;
}
private void CreateTestSubject(ProgressControllerViewModel state = null)
{
this.testSubject = new ProgressObserver(this.testServiceProvider, this.testVisualizer, this.progressEvents, state);
this.VerifyNonDisposedAndRegistered();
}
private static void VerifyExecutionGroup(ProgressObserver.ExecutionGroup group, IEnumerable<IProgressStep> orderedStepsInGroup)
{
Assert.AreEqual(orderedStepsInGroup.Count(), group.Steps.Count, "Unexpected number of actual steps in group");
int i = 0;
foreach (IProgressStep step in orderedStepsInGroup)
{
Assert.AreSame(step, group.Steps[i++], "Unexpected step in group");
}
}
public void ProgressObserver_StartObserving_DontConfiguresCancelCommand()
{
// Execute
this.testSubject = ProgressObserver.StartObserving(this.testServiceProvider, this.progressEvents, this.testVisualizer);
// Verify
Assert.IsNull(this.testSubject.CancelCommand, "CancelCommand should not be set");
}
public void ProgressObserver_StartObserving_ConfiguresCancelCommand()
{
bool aborted = false;
this.testController.TryAbortAction = () =>
{
aborted = true;
return true;
};
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
Assert.IsNotNull(this.testSubject.CancelCommand, "CancelCommand should be set");
this.testSubject.CancelCommand.Execute(null);
Assert.IsTrue(aborted, "TryAbort was configured to be called by the CancelCommand");
}
public void ProgressObserver_StopObserving_Twice()
{
this.testSubject = ProgressObserver.StartObserving(this.testController, this.testVisualizer);
ProgressObserver.StopObserving(this.testSubject);
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to be disposed");
ProgressObserver.StopObserving(this.testSubject);
Assert.IsTrue(this.testSubject.IsDisposed, "Expecting to remain disposed");
}
