public void Progress()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
progress?.Update(0.01f);
Assert.AreEqual(0.01f, progress?.PortionComplete ?? float.NaN);
Assert.AreEqual("", progress?.ItemCurrentlyBeingProcessed);
progress?.Update(0.02f, "test");
Assert.AreEqual(0.02f, progress?.PortionComplete ?? float.NaN);
Assert.AreEqual("test", progress?.ItemCurrentlyBeingProcessed);
progress?.Update(0.03f);
Assert.AreEqual(0.03f, progress?.PortionComplete ?? float.NaN);
Assert.AreEqual("test", progress?.ItemCurrentlyBeingProcessed);
progress?.Update(0.04f, "");
Assert.AreEqual(0.04f, progress?.PortionComplete ?? float.NaN);
Assert.AreEqual("", progress?.ItemCurrentlyBeingProcessed);
using (progress?.TrackPart(0.05f, 0.10f, null, true))
{
IAmbientProgress subprogress = AmbientProgressService.GlobalProgress;
subprogress?.ResetCancellation(TimeSpan.FromMilliseconds(5));
}
using (progress?.TrackPart(0.10f, 0.15f, null, false))
{
IAmbientProgress subprogress = AmbientProgressService.GlobalProgress;
subprogress?.ResetCancellation(TimeSpan.FromMilliseconds(5));
}
}
public async Task MainOperation(CancellationToken cancel = default(CancellationToken))
{
IAmbientProgress?progress = AmbientProgressService.Progress;
using (progress?.TrackPart(0.01f, 0.75f, "Download "))
{
await Download();
}
using (progress?.TrackPart(0.75f, 0.99f, "Unzip "))
{
await Unzip();
}
}
public void PortionTooLargeError()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.5f, 0.73f))
{
}
}
public void ProgressPartStack()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.05f, 0.10f))
{
Assert.AreNotEqual(progress, AmbientProgressService.GlobalProgress);
}
Assert.AreEqual(progress, AmbientProgressService.GlobalProgress);
}
public void PartPortionCompleteTooHighError()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.01f, 0.02f))
{
IAmbientProgress subprogress = AmbientProgressService.GlobalProgress;
subprogress?.Update(1.01f);
}
}
public void PartStackCorruption4()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
IDisposable subProgress1 = progress?.TrackPart(0.05f, 0.13f);
IDisposable subProgress2 = AmbientProgressService.GlobalProgress?.TrackPart(0.05f, 0.24f);
IDisposable subProgress3 = AmbientProgressService.GlobalProgress?.TrackPart(0.05f, 0.24f);
Assert.ThrowsException <InvalidOperationException>(() => subProgress2?.Dispose());
subProgress1?.Dispose();
Assert.ThrowsException <InvalidOperationException>(() => subProgress3?.Dispose());
}
public void DisposeTopLevelProgress()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
using (progress as IDisposable)
{
}
// this should create a new progress
progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.05f, 0.13f))
{
}
}
public void ProgressPart()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.05f, 0.05f, "prefix-"))
{
IAmbientProgress subprogress = AmbientProgressService.GlobalProgress;
Assert.AreEqual(0.0f, subprogress?.PortionComplete);
Assert.AreNotEqual(progress, AmbientProgressService.GlobalProgress);
subprogress?.Update(.5f, "subitem");
Assert.AreEqual(0.5f, subprogress?.PortionComplete);
Assert.AreEqual("subitem", subprogress?.ItemCurrentlyBeingProcessed);
Assert.AreEqual(0.075f, progress?.PortionComplete);
Assert.AreEqual("prefix-subitem", progress?.ItemCurrentlyBeingProcessed);
}
Assert.AreEqual(progress, AmbientProgressService.GlobalProgress);
Assert.AreEqual(0.10f, progress?.PortionComplete);
Assert.AreEqual("prefix-subitem", progress?.ItemCurrentlyBeingProcessed);
}
public void CancellationToken()
{
IAmbientProgress progress = AmbientProgressService.GlobalProgress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
if (progress?.GetType().Name == "SubProgress")
{
Assert.Fail("Progress: " + progress.ItemCurrentlyBeingProcessed + "(" + progress.PortionComplete + ")");
}
Assert.AreEqual("Progress", progress?.GetType().Name);
CancellationToken token = progress?.CancellationToken ?? default(CancellationToken);
Assert.IsFalse(token.IsCancellationRequested);
IDisposable subProgress1 = progress?.TrackPart(0.05f, 0.11f);
using (AmbientProgressService.GlobalProgress?.TrackPart(0.05f, 0.07f))
{
token = AmbientProgressService.GlobalProgress?.CancellationToken ?? default(CancellationToken);
Assert.IsFalse(token.IsCancellationRequested);
}
}
public void SubProgressCancellation()
{
IAmbientProgress progress = AmbientProgressService.Progress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
progress?.CancellationToken.ThrowIfCancellationRequested();
using (progress?.TrackPart(0.0f, 1.0f))
{
IAmbientProgress subprogress = AmbientProgressService.Progress;
using (AmbientClock.Pause())
{
subprogress?.ResetCancellation(TimeSpan.FromMilliseconds(104));
AmbientCancellationTokenSource tokenSource = subprogress?.CancellationTokenSource;
Assert.IsNotNull(tokenSource);
Assert.IsFalse(tokenSource?.IsCancellationRequested ?? true);
AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(106));
Assert.IsTrue(tokenSource?.IsCancellationRequested ?? false);
Assert.ThrowsException <OperationCanceledException>(() => AmbientProgressService.Progress?.ThrowIfCancelled());
}
}
}
public void SubProgressCancellationTokenSource()
{
IAmbientProgress progress = AmbientProgressService.Progress;
progress?.ResetCancellation(); // make a new cancellation in case the source was canceled in this execution context during a previous test
using (progress?.TrackPart(0.0f, 1.0f))
{
IAmbientProgress subprogress = AmbientProgressService.Progress;
using (AmbientClock.Pause())
{
subprogress?.ResetCancellation(TimeSpan.FromMilliseconds(100));
AmbientCancellationTokenSource tokenSource = subprogress?.CancellationTokenSource;
Assert.IsNotNull(tokenSource);
Assert.IsFalse(tokenSource?.IsCancellationRequested ?? true);
Assert.AreEqual(tokenSource?.Token, subprogress?.CancellationToken);
AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(100));
Assert.IsTrue(tokenSource?.IsCancellationRequested ?? false);
Assert.AreEqual(tokenSource?.Token, subprogress?.CancellationToken);
Assert.IsTrue(subprogress?.CancellationToken.IsCancellationRequested ?? false);
subprogress?.ResetCancellation(null);
AmbientCancellationTokenSource newTokenSource = subprogress?.CancellationTokenSource;
Assert.IsNotNull(newTokenSource);
Assert.IsFalse(newTokenSource?.IsCancellationRequested ?? true);
Assert.AreEqual(newTokenSource?.Token, subprogress?.CancellationToken);
AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(100));
Assert.IsFalse(newTokenSource?.IsCancellationRequested ?? true);
Assert.IsTrue(newTokenSource?.Token.CanBeCanceled ?? false);
Assert.AreEqual(newTokenSource?.Token, subprogress?.CancellationToken);
Assert.IsFalse(subprogress?.CancellationToken.IsCancellationRequested ?? true);
subprogress?.Update(0.5f);
subprogress?.ThrowIfCancelled();
}
}
}
