public static void TestObjectDisposedException()
{
IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestObjectDisposedException), new ProgressContext(), false);
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
e.Result = new FileOperationContext(String.Empty, ErrorStatus.Success);
return(Task.FromResult <object>(null));
};
try
{
worker.Run();
worker.Join();
}
finally
{
worker.Dispose();
}
bool hasCompleted = false;
Assert.Throws <ObjectDisposedException>(() => { worker.Run(); });
Assert.DoesNotThrow(() => { worker.Join(); });
Assert.DoesNotThrow(() => { hasCompleted = worker.HasCompleted; });
Assert.That(hasCompleted, "Even though the thread has completed, the variable should be set, since we allow calls to HasCompleted even after Dispose().");
Assert.DoesNotThrow(() => { worker.Dispose(); });
}
public static void TestRemovingSubscribersFromWorkerThread()
{
using (WorkerGroup workerGroup = new WorkerGroup())
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestRemovingSubscribersFromWorkerThread) + "1");
worker.Prepare += ThreadWorkerEventHandler;
worker.WorkAsync = ThreadWorkerCommandHandler;
worker.Completing += ThreadWorkerEventHandler;
worker.Run();
workerGroup.WaitAllAndFinish();
Assert.That(workerGroup.FirstError.ErrorStatus, Is.EqualTo(ErrorStatus.UnspecifiedError), "The status should be set by one of the event handlers.");
}
using (WorkerGroup workerGroup = new WorkerGroup())
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestRemovingSubscribersFromWorkerThread) + "2");
worker.Prepare += ThreadWorkerEventHandler;
worker.WorkAsync = ThreadWorkerCommandHandler;
worker.Completing += ThreadWorkerEventHandler;
worker.Prepare -= ThreadWorkerEventHandler;
worker.WorkAsync = null;
worker.Completing -= ThreadWorkerEventHandler;
worker.Run();
workerGroup.WaitAllAndFinish();
Assert.That(workerGroup.FirstError.ErrorStatus, Is.EqualTo(ErrorStatus.Success), "None of the event handlers should have been called, so the status should not have been set there.");
}
}
public static void TestAddingSubscribersToWorkerThread()
{
using (WorkerGroup workerGroup = new WorkerGroup())
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestAddingSubscribersToWorkerThread));
bool wasPrepared = false;
worker.Prepare += (object sender, ThreadWorkerEventArgs e) =>
{
wasPrepared = true;
};
bool didWork = false;
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
didWork = true;
return(Task.FromResult <object>(null));
};
bool didComplete = false;
worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
didComplete = true;
};
worker.Run();
workerGroup.WaitAllAndFinish();
Assert.That(wasPrepared, "The Prepare event should be raised.");
Assert.That(didWork, "The Work event should be raised.");
Assert.That(didComplete, "The Completed event should be raised.");
}
}
public static void TestProgress()
{
FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;
int progressCalls = 0;
ProgressContext progress = new ProgressContext();
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestProgress), progress, false))
{
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1);
e.Progress.AddCount(1);
e.Result = new FileOperationContext(String.Empty, ErrorStatus.Success);
return(Task.FromResult <object>(null));
};
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 TestSimple()
{
int workThreadId = -1;
FileOperationContext returnedStatus = new FileOperationContext(String.Empty, ErrorStatus.UnspecifiedError);
bool done = false;
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestSimple), new ProgressContext(), false))
{
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
workThreadId = Thread.CurrentThread.ManagedThreadId;
e.Result = new FileOperationContext(String.Empty, ErrorStatus.Success);
return(Task.FromResult <object>(null));
};
worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
returnedStatus = e.Result;
done = true;
};
worker.Run();
worker.Join();
}
Assert.That(returnedStatus.ErrorStatus, Is.EqualTo(ErrorStatus.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 TestFinishInBackground()
{
bool didComplete = false;
ProgressContext progress = new ProgressContext();
progress.Progressing += (object sender2, ProgressEventArgs e2) =>
{
didComplete = true;
};
using (IThreadWorker threadWorker = Resolve.Portable.ThreadWorker(nameof(TestFinishInBackground) + "Outer", progress, false))
{
threadWorker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
using (WorkerGroup workerGroup = new WorkerGroup(progress))
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestFinishInBackground) + "Inner");
worker.WorkAsync = (ThreadWorkerEventArgs e2) =>
{
e2.Progress.NotifyLevelStart();
e2.Progress.NotifyLevelFinished();
return(Task.FromResult <object>(null));
};
worker.Run();
}
return(Task.FromResult <object>(null));
};
threadWorker.Run();
threadWorker.Join();
}
Assert.That(didComplete, "Execution should continue here, with the flag set indicating that the progress event occurred.");
}
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.");
}
public static void TestDoubleFinished()
{
using (WorkerGroup workerGroup = new WorkerGroup())
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestDoubleFinished));
worker.Run();
workerGroup.WaitAllAndFinish();
Assert.Throws <InvalidOperationException>(() => { workerGroup.WaitAllAndFinish(); });
}
}
public static void TestDoubleDispose()
{
Assert.DoesNotThrow(() =>
{
using (WorkerGroup workerGroup = new WorkerGroup())
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestDoubleDispose));
worker.Run();
workerGroup.Dispose();
}
});
}
public static void TestCoreFunctionality()
{
int threadCount = 0;
int maxCount = 0;
using (WorkerGroup workerGroup = new WorkerGroup())
{
object threadLock = new object();
IThreadWorker worker1 = workerGroup.CreateWorker(nameof(TestCoreFunctionality) + "1");
worker1.WorkAsync = (ThreadWorkerEventArgs e) =>
{
lock (threadLock)
{
++threadCount;
if (threadCount > maxCount)
{
maxCount = threadCount;
}
}
Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
return(Task.FromResult <object>(null));
};
worker1.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
--threadCount;
};
worker1.Run();
IThreadWorker worker2 = workerGroup.CreateWorker(nameof(TestCoreFunctionality) + "2");
worker2.WorkAsync = (ThreadWorkerEventArgs e) =>
{
lock (threadLock)
{
++threadCount;
if (threadCount > maxCount)
{
maxCount = threadCount;
}
}
Thread.Sleep(new TimeSpan(0, 0, 0, 0, 100));
return(Task.FromResult <object>(null));
};
worker2.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
--threadCount;
};
worker2.Run();
workerGroup.WaitAllAndFinish();
Assert.That(maxCount, Is.EqualTo(1), "There should never be more than one thread active at one time.");
}
}
public static void TestObjectDisposed()
{
WorkerGroup workerGroup = new WorkerGroup();
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestObjectDisposed));
worker.Run();
workerGroup.Dispose();
worker = null;
Assert.Throws <ObjectDisposedException>(() => { worker = workerGroup.CreateWorker(nameof(TestObjectDisposed)); }, "A call to a method on a disposed object should raise ObjectDisposedException.");
Assert.That(worker, Is.Null, "The worker should still be null, since the previous attempt to create should fail with an exception.");
Assert.Throws <ObjectDisposedException>(() => { workerGroup.WaitAllAndFinish(); }, "A call to a method on a disposed object should raise ObjectDisposedException.");
}
public static void TestCoreFunctionality()
{
int threadCount = 0;
int maxCount = 0;
using (WorkerGroup workerGroup = new WorkerGroup())
{
object threadLock = new object();
IThreadWorker worker1 = workerGroup.CreateWorker();
worker1.Work += (object sender, ThreadWorkerEventArgs e) =>
{
lock (threadLock)
{
++threadCount;
if (threadCount > maxCount)
{
maxCount = threadCount;
}
}
Thread.Sleep(100);
};
worker1.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
--threadCount;
};
worker1.Run();
IThreadWorker worker2 = workerGroup.CreateWorker();
worker2.Work += (object sender, ThreadWorkerEventArgs e) =>
{
lock (threadLock)
{
++threadCount;
if (threadCount > maxCount)
{
maxCount = threadCount;
}
}
Thread.Sleep(100);
};
worker2.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
--threadCount;
};
worker2.Run();
workerGroup.WaitAllAndFinish();
Assert.That(maxCount, Is.EqualTo(1), "There should never be more than one thread active at one time.");
}
}
public static void TestProgressing()
{
using (WorkerGroup workerGroup = new WorkerGroup())
{
int percent = 0;
workerGroup.Progress.Progressing += (object sender, ProgressEventArgs e) =>
{
percent = e.Percent;
};
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestProgressing));
worker.Run();
workerGroup.WaitAllAndFinish();
Assert.That(percent, Is.EqualTo(100), "Progress at 100 percent should always be reported when the thread completes.");
}
}
public static void TestPrepare()
{
bool wasPrepared = false;
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestPrepare), new ProgressContext(), false))
{
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 TestExplicitConstructor()
{
ProgressContext progress = new ProgressContext();
int percent = 0;
progress.Progressing += (object sender, ProgressEventArgs e) =>
{
percent = e.Percent;
};
using (WorkerGroup workerGroup = new WorkerGroup(1, progress))
{
IThreadWorker worker = workerGroup.CreateWorker(nameof(TestExplicitConstructor));
worker.Run();
workerGroup.WaitAllAndFinish();
}
Assert.That(percent, Is.EqualTo(100), "Progress at 100 percent should always be reported when the thread completes.");
}
private void DoFile(string fullName, IThreadWorker worker, Func <string, bool> preparation, Func <bool> operation)
{
if (!preparation(fullName))
{
worker.Abort();
OnCompleted(_eventArgs);
return;
}
worker.Work += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
{
operation();
};
worker.Completing += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
{
_eventArgs.Status = threadWorkerEventArgs.Result;
OnCompleted(_eventArgs);
};
worker.Run();
}
public static void TestCancellationByException()
{
bool wasCanceled = false;
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestCancellationByException), new ProgressContext(), false))
{
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
throw new OperationCanceledException();
};
worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
wasCanceled = e.Result.ErrorStatus == ErrorStatus.Canceled;
};
worker.Run();
worker.Join();
}
Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such.");
}
public static void TestErrorSetInWorkCompleted()
{
bool errorInWork = false;
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestErrorSetInWorkCompleted), new ProgressContext(), false))
{
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
throw new InvalidOperationException();
};
worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
errorInWork = e.Result.ErrorStatus == ErrorStatus.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 TestExceptionDuringWork()
{
FileOperationContext status = new FileOperationContext(String.Empty, ErrorStatus.Unknown);
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestExceptionDuringWork), new ProgressContext(), false))
{
worker.WorkAsync = (e) =>
{
throw new InvalidOperationException("Something went intentionally wrong.");
};
worker.Completed += (sender, e) =>
{
status = e.Result;
};
worker.Run();
worker.Join();
}
Assert.That(status.ErrorStatus, Is.EqualTo(ErrorStatus.Exception));
}
public static void TestHasCompleted()
{
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestHasCompleted), new ProgressContext(), false))
{
bool wasCompletedInWork = false;
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
wasCompletedInWork = worker.HasCompleted;
return(Task.FromResult <object>(null));
};
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 TestCancellationByRequest()
{
bool wasCanceled = false;
FakeRuntimeEnvironment environment = (FakeRuntimeEnvironment)OS.Current;
using (IThreadWorker worker = Resolve.Portable.ThreadWorker(nameof(TestCancellationByRequest), new CancelProgressContext(new ProgressContext()), false))
{
worker.WorkAsync = (ThreadWorkerEventArgs e) =>
{
e.Progress.Cancel = true;
environment.CurrentTiming.CurrentTiming = TimeSpan.FromSeconds(1);
e.Progress.AddCount(1);
return(Task.FromResult <object>(null));
};
worker.Completing += (object sender, ThreadWorkerEventArgs e) =>
{
wasCanceled = e.Result.ErrorStatus == ErrorStatus.Canceled;
};
worker.Run();
worker.Join();
}
Assert.That(wasCanceled, Is.True, "The operation was canceled and should return status as such.");
}
private void DoFile(string fullName, IThreadWorker worker, Func<string, bool> preparation, Func<bool> operation)
{
if (!preparation(fullName))
{
worker.Abort();
OnCompleted(_eventArgs);
return;
}
worker.Work += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
{
operation();
};
worker.Completing += (object workerSender, ThreadWorkerEventArgs threadWorkerEventArgs) =>
{
_eventArgs.Status = threadWorkerEventArgs.Result;
OnCompleted(_eventArgs);
};
worker.Run();
}
/// <summary>
/// Start the asynchronous execution of the work.
/// </summary>
public void Run()
{
_worker.Run();
}
