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 void PortionCompleteTooHighError() { 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(1.01f); }
public void ProgressThread() { 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.25f, "main"); Thread thread = new Thread(new ParameterizedThreadStart(o => { // the progress here should be a SEPARATE progress because it's a separate execution thread IAmbientProgress threadProgress = AmbientProgressService.GlobalProgress; threadProgress?.Update(0.75f, "thread"); threadProgress?.Update(0.33f, "cross-thread"); })); thread.Start(); thread.Join(); Assert.AreEqual(0.33f, progress?.PortionComplete ?? 0); }
public void PartPortionCompleteTooLowError() { 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(-.01f); } }
public Task Unzip() { IAmbientProgress? progress = AmbientProgressService.Progress; CancellationToken cancel = progress?.CancellationToken ?? default(CancellationToken); ZipArchive archive = new ZipArchive(_package); int entries = archive.Entries.Count; for (int entry = 0; entry < entries; ++entry) { ZipArchiveEntry archiveEntry = archive.Entries[entry]; // update the progress progress?.Update(entry * 1.0f / entries, archiveEntry.FullName); archiveEntry.ExtractToFile(Path.Combine(_targetFolder, archiveEntry.FullName)); } return(Task.CompletedTask); }
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 async Task Download() { IAmbientProgress? progress = AmbientProgressService.Progress; CancellationToken cancel = progress?.CancellationToken ?? default(CancellationToken); HttpWebRequest request = HttpWebRequest.CreateHttp(_downlaodUrl); using (WebResponse response = request.GetResponse()) { long totalBytesRead = 0; int bytesRead; long totalBytes = response.ContentLength; byte[] buffer = new byte[8192]; using (Stream downloadReader = response.GetResponseStream()) { while ((bytesRead = await downloadReader.ReadAsync(buffer, 0, buffer.Length, cancel)) != 0) { await _package.WriteAsync(buffer, 0, bytesRead, cancel); totalBytesRead += bytesRead; progress?.Update(totalBytesRead * 1.0f / totalBytes); } } } }
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(); } } }
public void CancellationTokenSource() { 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 (AmbientClock.Pause()) { progress?.ResetCancellation(TimeSpan.FromMilliseconds(102)); using (AmbientCancellationTokenSource tokenSource = progress?.CancellationTokenSource) { Assert.IsNotNull(tokenSource); Assert.IsFalse(tokenSource?.IsCancellationRequested ?? true); Assert.AreEqual(tokenSource?.Token, progress?.CancellationToken); AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(111)); Assert.IsTrue(tokenSource?.IsCancellationRequested ?? false); Assert.AreEqual(tokenSource?.Token, progress?.CancellationToken); Assert.IsTrue(progress?.CancellationToken.IsCancellationRequested ?? false); progress?.ResetCancellation(); AmbientCancellationTokenSource newTokenSource = progress?.CancellationTokenSource; Assert.IsNotNull(newTokenSource); Assert.IsFalse(newTokenSource?.IsCancellationRequested ?? true); Assert.AreEqual(newTokenSource?.Token, progress?.CancellationToken); AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(100)); Assert.IsFalse(newTokenSource?.IsCancellationRequested ?? true); Assert.IsTrue(newTokenSource?.Token.CanBeCanceled ?? false); Assert.AreEqual(newTokenSource?.Token, progress?.CancellationToken); Assert.IsFalse(progress?.CancellationToken.IsCancellationRequested ?? true); progress?.Update(0.5f); progress?.ThrowIfCancelled(); using (CancellationTokenSource ts = new CancellationTokenSource()) { progress?.ResetCancellation(ts); newTokenSource = progress?.CancellationTokenSource; Assert.IsNotNull(newTokenSource); Assert.IsFalse(newTokenSource?.IsCancellationRequested ?? true); Assert.AreEqual(newTokenSource?.Token, progress?.CancellationToken); Assert.IsTrue(newTokenSource?.Token.CanBeCanceled ?? false); ts.Cancel(); Assert.IsTrue(newTokenSource?.IsCancellationRequested ?? false); Assert.AreEqual(newTokenSource?.Token, progress?.CancellationToken); Assert.IsTrue(progress?.CancellationToken.IsCancellationRequested ?? false); } using (AmbientCancellationTokenSource ts = new AmbientCancellationTokenSource(null, null)) { Assert.IsFalse(ts.IsCancellationRequested); Assert.IsFalse(ts.Token.IsCancellationRequested); ts.Dispose(); Assert.IsTrue(ts.IsCancellationRequested); Assert.IsTrue(ts.Token.IsCancellationRequested); } using (AmbientCancellationTokenSource ts = new AmbientCancellationTokenSource(null, TimeSpan.FromMilliseconds(int.MaxValue))) { Assert.IsFalse(ts.IsCancellationRequested); // theoretically, this could fail if this part of the test takes more than 30 days to execute Assert.IsFalse(ts.Token.IsCancellationRequested); ts.Dispose(); Assert.IsTrue(ts.IsCancellationRequested); Assert.IsTrue(ts.Token.IsCancellationRequested); } AmbientCancellationTokenSource dispose; using (AmbientCancellationTokenSource ts = new AmbientCancellationTokenSource()) { dispose = ts; } dispose.CancelAfter(1); System.Threading.Thread.Sleep(500); AmbientClock.SkipAhead(TimeSpan.FromMilliseconds(500)); dispose.Cancel(false); } } }