public static void TestCancellationByException() { bool wasCanceled = false; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { worker.Work += (object sender, ThreadWorkerEventArgs e) => { throw new OperationCanceledException(); }; worker.Completing += (object sender, ThreadWorkerEventArgs e) => { wasCanceled = e.Result == FileOperationStatus.Canceled; }; worker.Run(); worker.Join(); } Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such."); }
public static void TestCancellationByRequest() { bool wasCanceled = false; FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { worker.Work += (object sender, ThreadWorkerEventArgs e) => { e.Progress.Cancel = true; environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1); e.Progress.AddCount(1); }; worker.Completing += (object sender, ThreadWorkerEventArgs e) => { wasCanceled = e.Result == FileOperationStatus.Canceled; }; worker.Run(); worker.Join(); } Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such."); }
public static void TestSimple() { int workThreadId = -1; FileOperationStatus returnedStatus = FileOperationStatus.UnspecifiedError; bool done = false; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { worker.Work += (object sender, ThreadWorkerEventArgs e) => { workThreadId = Thread.CurrentThread.ManagedThreadId; e.Result = FileOperationStatus.Success; }; worker.Completing += (object sender, ThreadWorkerEventArgs e) => { returnedStatus = e.Result; done = true; }; worker.Run(); worker.Join(); } Assert.That(returnedStatus, Is.EqualTo(FileOperationStatus.Success), "The status should be returned as successful."); Assert.That(workThreadId, Is.Not.EqualTo(Thread.CurrentThread.ManagedThreadId), "The work should not be performed on the caller thread."); Assert.That(done, Is.True, "The background work must have executed the completed handler now."); }
public static void TestPrepare() { bool wasPrepared = false; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { worker.Prepare += (object sender, ThreadWorkerEventArgs e) => { wasPrepared = true; }; worker.Run(); worker.Join(); } Assert.That(wasPrepared, Is.True, "The Prepare event should be raised."); }
public static void TestProgress() { FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current; int progressCalls = 0; ProgressContext progress = new ProgressContext(); using (ThreadWorker worker = new ThreadWorker(progress)) { worker.Work += (object sender, ThreadWorkerEventArgs e) => { environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1); e.Progress.AddCount(1); e.Result = FileOperationStatus.Success; }; progress.Progressing += (object sender, ProgressEventArgs e) => { ++progressCalls; }; worker.Run(); worker.Join(); } Assert.That(progressCalls, Is.EqualTo(1), "The Progressing event should be raised exactly one time."); }
public static void TestObjectDisposedException() { ThreadWorker worker = new ThreadWorker(new ProgressContext()); worker.Work += (object sender, ThreadWorkerEventArgs e) => { e.Result = FileOperationStatus.Success; }; try { worker.Run(); worker.Join(); } finally { worker.Dispose(); } bool hasCompleted = false; Assert.Throws<ObjectDisposedException>(() => { worker.Run(); }); Assert.Throws<ObjectDisposedException>(() => { worker.Join(); }); Assert.Throws<ObjectDisposedException>(() => { hasCompleted = worker.HasCompleted; }); Assert.That(!hasCompleted, "Although the thread has completed, the variable should still be false since the attempt to set it is after Dispose()."); Assert.DoesNotThrow(() => { worker.Dispose(); }); }
public static void TestHasCompleted() { using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { bool wasCompletedInWork = false; worker.Work += (object sender, ThreadWorkerEventArgs e) => { wasCompletedInWork = worker.HasCompleted; }; bool wasCompletedInCompleted = false; worker.Completing += (object sender, ThreadWorkerEventArgs e) => { wasCompletedInCompleted = worker.HasCompleted; }; worker.Run(); worker.Join(); Assert.That(!wasCompletedInWork, "Completion is not set as true in the work event."); Assert.That(!wasCompletedInCompleted, "Completion is not set as true until after the completed event."); Assert.That(worker.HasCompleted, "Completion should be set as true when the thread is joined."); } }
public static void TestErrorSetInWorkCompleted() { bool errorInWork = false; using (ThreadWorker worker = new ThreadWorker(new ProgressContext())) { worker.Work += (object sender, ThreadWorkerEventArgs e) => { throw new InvalidOperationException(); }; worker.Completing += (object sender, ThreadWorkerEventArgs e) => { errorInWork = e.Result == FileOperationStatus.Exception; }; worker.Run(); worker.Join(); } Assert.That(errorInWork, Is.True, "The operation was interrupted by an exception and should return status as such."); }
public static void TestFinishInBackground() { bool didComplete = false; ProgressContext progress = new ProgressContext(); progress.Progressing += (object sender2, ProgressEventArgs e2) => { didComplete = true; }; using (ThreadWorker threadWorker = new ThreadWorker(progress)) { threadWorker.Work += (object sender, ThreadWorkerEventArgs e) => { using (WorkerGroup workerGroup = new WorkerGroup(progress)) { IThreadWorker worker = workerGroup.CreateWorker(); worker.Work += (object sender2, ThreadWorkerEventArgs e2) => { e2.Progress.NotifyLevelStart(); e2.Progress.NotifyLevelFinished(); }; worker.Run(); } }; threadWorker.Run(); } Assert.That(didComplete, "Execution should continue here, with the flag set indicating that the progress event occurred."); }
/// <summary> /// Perform a background operation with support for progress bars and cancel. /// </summary> /// <param name="displayText">A text that may be used as a reference in various messages.</param> /// <param name="work">A 'work' delegate, taking a ProgressContext and return a FileOperationStatus. Executed on a background thread. Not the calling/GUI thread.</param> /// <param name="complete">A 'complete' delegate, taking the final status. Executed on the original caller thread, typically the GUI thread.</param> public void BackgroundWorkWithProgress(Func<ProgressContext, FileOperationStatus> work, Action<FileOperationStatus> complete) { ProgressContext progress = new ProgressContext(); ProgressBar progressBar = CreateProgressBar(progress); OnProgressBarCreated(new ControlEventArgs(progressBar)); progress.Progressing += (object sender, ProgressEventArgs e) => { progressBar.Value = e.Percent; }; ThreadWorker threadWorker = new ThreadWorker(progress); threadWorker.Work += (object sender, ThreadWorkerEventArgs e) => { e.Result = work(e.Progress); }; threadWorker.Completing += (object sender, ThreadWorkerEventArgs e) => { try { complete(e.Result); progressBar.Parent = null; } finally { progressBar.Dispose(); } }; threadWorker.Completed += (object sender, ThreadWorkerEventArgs e) => { IDisposable disposable = sender as IDisposable; if (disposable != null) { disposable.Dispose(); } Interlocked.Decrement(ref _workerCount); }; Interlocked.Increment(ref _workerCount); threadWorker.Run(); }