private void MultipleWorkerMultipleTaskTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var tasks = Enumerable.Range(0, 30).Select(i => new TestTask($"multi {i}")).ToArray();
var taskMons = tasks.Select(t => new EventMonitor <TestTask>(t)).ToArray();
Assert.IsTrue(q.IsEmpty);
wl.Enqueue(tasks);
wl.WaitForEnd(timeout: 10000);
Assert.IsTrue(q.IsEmpty);
AssertState(wl, isDisposed: false, busy: false);
Assert.AreEqual(tasks.Length, wlMon.FilterHistory(ByEventName(nameof(WorkingLine.TaskBegin))).Count);
Assert.AreEqual(tasks.Length, wlMon.FilterHistory(ByEventName(nameof(WorkingLine.TaskEnd))).Count);
wlMon.History.AssertSender(wl);
wlMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkingLine.Busy)))
.AssertPropertyValues(true, false);
wlMon.FilterHistory(ByPropertyChanges <int>(nameof(WorkingLine.BusyWorkerCount)))
.AssertPropertyValueChanges <int>()
.AssertPropertyValues(1, 2, 3, 2, 1, 0);
for (int i = 0; i < tasks.Length; i++)
{
var task = tasks[i];
var taskMon = taskMons[i];
taskMon.History.AssertSender(task);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
}
}
private void SingleTaskTestAfterFinish(TaskManager tm, EventMonitor <TaskManager> tmMon,
EventMonitor <TestTask> taskMon)
{
AssertState(tm, isDisposed: false, isRunning: false);
tmMon.FilterHistory(ByEventName(
nameof(TaskManager.IsRunningChanged),
nameof(TaskManager.Started),
nameof(TaskManager.Finished),
nameof(TaskManager.TaskBegin),
nameof(TaskManager.TaskEnd)))
.AssertSender(tm)
.AssertEventNames(
nameof(TaskManager.Started),
nameof(TaskManager.IsRunningChanged),
nameof(TaskManager.TaskBegin),
nameof(TaskManager.TaskEnd),
nameof(TaskManager.IsRunningChanged),
nameof(TaskManager.Finished));
tmMon.FilterHistory(ByPropertyChanges <bool>(nameof(TaskManager.IsRunning)))
.AssertPropertyValues(true, false);
taskMon.History.AssertSender(taskMon.Target);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
}
private void WithWorkerThread(Action <WorkerThread, EventMonitor <WorkerThread> > testCase, bool started = true, bool expectStopped = false)
{
var wt = CreateWorkerThread();
var wtMon = new EventMonitor <WorkerThread>(wt);
if (started)
{
wt.Start();
AssertState(wt, isDisposed: false, isAlive: true, busy: false);
wtMon.History.AssertSender(wt);
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.IsAlive)))
.AssertPropertyValues(true);
}
wtMon.ClearHistory();
testCase(wt, wtMon);
wtMon.ClearHistory();
wt.Queue.Dispose();
wt.Dispose();
AssertState(wt, isDisposed: true, isAlive: false, busy: false);
wtMon.History.AssertSender(wt);
if (expectStopped)
{
Assert.IsTrue(
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.IsAlive)))
.IsEmpty);
}
else
{
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.IsAlive)))
.AssertPropertyValues(false);
}
}
private void MultiTaskTestCase(WorkerThread wt, EventMonitor <WorkerThread> wtMon)
{
var q = wt.Queue;
var tasks = new[] {
new TestTask("multi 1"),
new TestTask("multi 2"),
new TestTask("multi 3")
};
var taskMons = tasks.Select(t => new EventMonitor <TestTask>(t)).ToArray();
foreach (var task in tasks)
{
q.Enqueue(task);
}
Assert.IsTrue(wt.WaitForEnd(timeout: 10000));
Assert.IsTrue(q.IsEmpty);
AssertState(wt, isDisposed: false, isAlive: true, busy: false);
var wtHist = wtMon.History;
wtHist.AssertSender(wt);
wtHist.AssertEventNames(
nameof(WorkerThread.BusyChanged),
nameof(WorkerThread.CurrentTaskChanged),
nameof(WorkerThread.TaskBegin),
nameof(WorkerThread.TaskEnd),
nameof(WorkerThread.CurrentTaskChanged),
nameof(WorkerThread.TaskBegin),
nameof(WorkerThread.TaskEnd),
nameof(WorkerThread.CurrentTaskChanged),
nameof(WorkerThread.TaskBegin),
nameof(WorkerThread.TaskEnd),
nameof(WorkerThread.CurrentTaskChanged),
nameof(WorkerThread.BusyChanged));
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.Busy)))
.AssertPropertyValues(true, false);
wtMon.FilterHistory(ByPropertyChanges <ITask>(nameof(WorkerThread.CurrentTask)))
.AssertPropertyValues(tasks.Concat(new TestTask[] { null }).ToArray());
for (int i = 0; i < tasks.Length; i++)
{
var taskMon = taskMons[i];
var task = tasks[i];
var taskHist = taskMon.History;
taskHist.AssertSender(task);
var taskStateHist = taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)));
taskStateHist.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
var taskProgressHist = taskMon.FilterHistory(ByPropertyChanges <float>(nameof(ITask.Progress)));
Assert.IsTrue(taskProgressHist.Count > 0);
Assert.AreEqual(0f, taskProgressHist.First.GetNewValue <float>());
Assert.AreEqual(1f, taskProgressHist.Last.GetNewValue <float>());
}
}
private void SingleTaskTestCase(WorkerThread wt, EventMonitor <WorkerThread> wtMon)
{
var q = wt.Queue;
var task = new TestTask("single");
var taskMon = new EventMonitor <TestTask>(task);
q.Enqueue(task);
Assert.IsFalse(q.IsEmpty);
AssertState(wt, isDisposed: false, isAlive: false, busy: false);
wt.Start();
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.IsAlive)))
.AssertPropertyValues(true);
//WaitFor(() => task.State == TaskState.Succeeded, 1000);
wt.WaitForEnd(timeout: 10000);
Assert.IsTrue(q.IsEmpty);
AssertState(wt, isDisposed: false, isAlive: true, busy: false);
var wtHist = wtMon.History;
wtHist.AssertSender(wt);
wtHist.AssertEventNames(
nameof(wt.IsAliveChanged),
nameof(wt.BusyChanged),
nameof(wt.CurrentTaskChanged),
nameof(wt.TaskBegin),
nameof(wt.TaskEnd),
nameof(wt.CurrentTaskChanged),
nameof(wt.BusyChanged));
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.IsAlive)))
.AssertPropertyValues(true);
wtMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkerThread.Busy)))
.AssertPropertyValues(true, false);
wtMon.FilterHistory(ByPropertyChanges <ITask>(nameof(WorkerThread.CurrentTask)))
.AssertPropertyValues(task, null);
taskMon.History.AssertSender(task);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(TestTask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded
);
AssertTaskProgressRange(taskMon);
}
private void ParallelCancellationTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var tasks = Enumerable.Range(0, 18).Select(i => new TestTask(i.ToString())).ToArray();
var taskMons = tasks.Select(t => new EventMonitor <TestTask>(t)).ToArray();
var cancelTask = tasks[9];
cancelTask.StateChanging += (s, e) =>
{
if (e.NewValue == TaskState.InProgress)
{
wl.Cancel();
}
};
wl.Enqueue(tasks);
Assert.IsTrue(wl.WaitForEnd(timeout: 4000));
AssertState(wl, isDisposed: false, busy: false);
Assert.AreEqual(0, wl.CurrentTasks.Length);
Assert.IsTrue(wl.Queue.IsEmpty);
Assert.AreEqual(TaskState.Succeeded, tasks.First().State);
Assert.AreEqual(TaskState.Obsolete, tasks.Last().State);
Assert.AreEqual(tasks.Length,
tasks.Where(t =>
t.State == TaskState.Succeeded ||
t.State == TaskState.Canceled ||
t.State == TaskState.Obsolete)
.Count());
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.Cancelled)))
.AssertEventNames(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.Cancelled),
nameof(WorkingLine.BusyChanged));
wlMon.FilterHistory(ByEventName(nameof(WorkingLine.BusyChanged)))
.AssertPropertyValues(true, false);
wlMon.FilterHistory(ByEventName(nameof(WorkingLine.BusyWorkerCountChanged)))
.AssertPropertyValues(1, 2, 3, 2, 1, 0);
}
private void AssertTaskProgressRange(EventMonitor <TestTask> taskMonitor, float first = 0f, float last = 1f)
{
var progressHistory = taskMonitor.FilterHistory(ByPropertyChanges <float>(nameof(TestTask.Progress)));
Assert.IsTrue(progressHistory.Count > 0, "No progress events fired.");
Assert.AreEqual(first, progressHistory.First.GetNewValue <float>(), $"The first progress event did not signal {first}.");
Assert.AreEqual(last, progressHistory.Last.GetNewValue <float>(), $"The last progress event did not signal {last}.");
}
private void GeneralTasksAfterFinish(TaskManager tm, EventMonitor <TaskManager> tmMon,
TaskGraphMonitor tgMon)
{
var queueTags = tm.WorkingLines.Select(wl => wl.QueueTag).ToArray();
AssertState(tm, isDisposed: false, isRunning: false);
tmMon.History.AssertSender(tm);
tmMon.FilterHistory(ByPropertyChanges <bool>(nameof(TaskManager.IsRunning)))
.AssertPropertyValues(true, false);
var labels = tgMon.Tasks.Select(t => t.Label).ToList();
var beginLabels = tmMon.FilterHistory(ByEventName(nameof(TaskManager.TaskBegin)))
.Select(e => ((TestTask)((TaskEventArgs)e.EventArgs).Task).Label).ToList();
var unstartedLabels = labels.Except(beginLabels).ToList();
if (unstartedLabels.Count > 0)
{
Debug.WriteLine("Task without begin event: " + string.Join(", ", unstartedLabels));
Assert.Fail("The following tasks did not fire a begin event: " + string.Join(", ", unstartedLabels));
}
var endLabels = tmMon.FilterHistory(ByEventName(nameof(TaskManager.TaskEnd)))
.Select(e => ((TestTask)((TaskEventArgs)e.EventArgs).Task).Label).ToList();
var unfinishedLabels = labels.Except(endLabels).ToList();
if (unfinishedLabels.Count > 0)
{
Debug.WriteLine("Task without end event: " + string.Join(", ", unfinishedLabels));
Assert.Fail("The following tasks did not fire an end event: " + string.Join(", ", unfinishedLabels));
}
foreach (var taskMon in tgMon.TaskMonitors)
{
taskMon.History.AssertSender(taskMon.Target);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
}
tgMon.AssertTaskEventsRespectDependencies();
}
private void SingleWorkerSingleTaskTestCase(WorkingLine wl, EventMonitor <WorkingLine> wlMon)
{
var q = wl.Queue;
var task = new TestTask("single");
var taskMon = new EventMonitor <TestTask>(task);
Assert.IsTrue(q.IsEmpty);
wl.Enqueue(task);
Assert.IsFalse(q.IsEmpty);
AssertState(wl, isDisposed: false, busy: false);
wl.Start();
wl.WaitForEnd(timeout: 10000);
Assert.IsTrue(q.IsEmpty);
AssertState(wl, isDisposed: false, busy: false);
wlMon.History.AssertSender(wl);
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.TaskEnd)))
.AssertEventNames(
nameof(WorkingLine.TaskBegin),
nameof(WorkingLine.TaskEnd));
wlMon.FilterHistory(ByEventName(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.BusyWorkerCountChanged)))
.AssertEventNames(
nameof(WorkingLine.BusyChanged),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.BusyWorkerCountChanged),
nameof(WorkingLine.BusyChanged));
wlMon.FilterHistory(ByPropertyChanges <bool>(nameof(WorkingLine.Busy)))
.AssertPropertyValues(true, false);
wlMon.FilterHistory(ByPropertyChanges <int>(nameof(WorkingLine.BusyWorkerCount)))
.AssertPropertyValues(1, 0);
taskMon.History.AssertSender(task);
taskMon.FilterHistory(ByPropertyChanges <TaskState>(nameof(ITask.State)))
.AssertPropertyValues(
TaskState.InProgress,
TaskState.CleaningUp,
TaskState.Succeeded);
}
private void LifeCycleTestAfterFinish(TaskManager tm, EventMonitor <TaskManager> tmMon, object cache)
{
AssertState(tm, isDisposed: false, isRunning: false);
tmMon.History
.AssertSender(tm)
.AssertEventNames(
nameof(TaskManager.Started),
nameof(TaskManager.IsRunningChanged),
nameof(TaskManager.IsRunningChanged),
nameof(TaskManager.Finished));
tmMon.FilterHistory(ByPropertyChanges <bool>(nameof(TaskManager.IsRunning)))
.AssertPropertyValues(true, false);
}
