public async Task run_CancelTest()
{
FifoTaskQueue queue = CreateTaskQueue();
bool firstTaskFinished = false;
bool secondTaskfinished = false;
bool thirdTaskStarted = false;
queue.Run(() =>
{
// queue.CancelExecution();
Task.Delay(5000, queue.CancellationToken).Wait();
firstTaskFinished = true;
});
queue.Run((dummyObject) =>
{
secondTaskfinished = true;
}, new object());
queue.Run((dummyObject) =>
{
thirdTaskStarted = false;
}, new object());
bool done = await queue.CancelAfter(2000, EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsFaulted, "First Task faulted");
Assert.IsFalse(firstTaskFinished, "First Task's Action not terminated");
Assert.IsTrue(queue.Tasks[1].IsCanceled, "Second Task Canceled");
Assert.IsFalse(secondTaskfinished, "Second not finished");
Assert.IsTrue(queue.Tasks[2].IsCanceled, "third Task Canceled");
Assert.IsFalse(thirdTaskStarted, "third task not finished");
queue.Dispose();
}
public async Task Run_WithParameters_RunOrderIsSequentialTest()
{
FifoTaskQueue queue = CreateTaskQueue();
bool firstRun = false;
bool secondRun = false;
bool thirdRun = false;
queue.Run((testx) =>
{
firstRun = true;
Assert.IsTrue(firstRun == true && secondRun == false && thirdRun == false);
}, new object());
queue.Run((testx) =>
{
secondRun = true;
Assert.IsTrue(firstRun == true && secondRun == true && thirdRun == false);
}, new Object());
queue.Run((testx) =>
{
thirdRun = true;
Assert.IsTrue(firstRun == true && secondRun == true && thirdRun == true);
}, new Object());
bool done = await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsCompleted, "first task completed");
Assert.IsTrue(queue.Tasks[1].IsCompleted, "second task completed");
Assert.IsTrue(queue.Tasks[2].IsCompleted, "third task completed");
queue.Dispose();
Assert.IsTrue(queue.Tasks.Count == 0, "All Tasks where disposed!");
}
public async Task Run_WithParameters_ShareObject()
{
object[] objectRerenceToShare = new object[3];
FifoTaskQueue queue = CreateTaskQueue();
queue.Run((sharedObject) =>
{
((object[])sharedObject)[0] = "a";
Assert.IsTrue(object.ReferenceEquals(sharedObject, objectRerenceToShare),
"object is the same at first iteration");
}, objectRerenceToShare);
queue.Run((sharedObject) =>
{
((object[])sharedObject)[1] = "b";
Assert.IsTrue(object.ReferenceEquals(sharedObject, objectRerenceToShare),
"object is the same at second iteration");
}, objectRerenceToShare);
queue.Run((sharedObject) =>
{
((object[])sharedObject)[2] = "c";
Assert.IsTrue(object.ReferenceEquals(sharedObject, objectRerenceToShare),
"object is the same at third iteration");
}, objectRerenceToShare);
bool done = await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsCompleted, "first task completed");
Assert.IsTrue(queue.Tasks[1].IsCompleted, "second task completed");
Assert.IsTrue(queue.Tasks[2].IsCompleted, "third task completed");
Assert.AreEqual("a b c", String.Join(" ", objectRerenceToShare));
queue.Dispose();
}
public async Task Run_WithParameters_ParametersAreUnmutableTest()
{
FifoTaskQueue queue = CreateTaskQueue();
int countIterations = 0;
queue.Run((parameters) =>
{
Task.Delay(1000).Wait();
countIterations++;
Assert.AreEqual(1, countIterations);
Assert.AreEqual(0, parameters);
}, countIterations);
queue.Run((parameters) =>
{
countIterations++;
Assert.AreEqual(2, countIterations);
Assert.AreEqual(0, parameters);
}, countIterations);
queue.Run((parameters) =>
{
countIterations++;
Assert.AreEqual(3, countIterations);
Assert.AreEqual(0, parameters);
}, countIterations);
bool done = await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsCompleted, "Task 1 is completed");
Assert.IsTrue(queue.Tasks[1].IsCompleted, "Task 2 is completed");
Assert.IsTrue(queue.Tasks[2].IsCompleted, "Task 3 is completed");
queue.Dispose();
Assert.IsTrue(queue.Tasks.Count == 0, "All Tasks where disposed!");
}
private FifoTaskQueue CreateTaskQueue()
{
Mock <ILogger> logger = new Mock <ILogger>();
logger.Setup(p => p.Info(It.IsAny <string>()));
logger.Setup(p => p.Debug(It.IsAny <string>()));
logger.Setup(p => p.Warn(It.IsAny <string>()));
logger.Setup(p => p.Error(It.IsAny <string>()));
return(FifoTaskQueue.Create(TaskShedulerWraper.Create().FromCurrentWorker(),
TasksProvider.Create(new List <Task>(), logger.Object), logger.Object));
}
public async Task AllTaskRemovedAfterCompletationOfEachObservationTest()
{
FifoTaskQueue queue = CreateTaskQueue();
queue.Run(() => { });
queue.Run(() => { });
queue.Run(() => { });
bool done = await queue.ObserveCompletation();
Assert.IsTrue(queue.Tasks.Count() == 0);
queue.Dispose();
}
public async Task ClearUp_Tasks_TasksFinishedTest()
{
FifoTaskQueue queue = CreateTaskQueue();
queue.Run(() => { });
queue.Run(() => { });
queue.Run(() => { });
bool done = await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsCompleted == true &&
queue.Tasks[1].IsCompleted == true &&
queue.Tasks[2].IsCompleted == true);
queue.ClearUpTasks();
Assert.IsTrue(queue.Tasks.Count() == 0);
queue.Dispose();
}
public async Task Complete_SecondTaskBrokenTest()
{
FifoTaskQueue queue = CreateTaskQueue();
bool taskExecuted = false;
queue.Run(() => { });
queue.Run(() => {
Task.Delay(5000, queue.CancellationToken).Wait();
taskExecuted = true;
});
queue.Run(() => { });
queue.Run(() => { });
int elapsedTimeToCancelQueue = 2000;
await queue.CancelAfter(elapsedTimeToCancelQueue, EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsCompleted, "First Task Completed");
Assert.IsTrue(queue.Tasks[1].IsFaulted && taskExecuted == false, "second Task faulted and broken");
Assert.IsTrue(queue.Tasks[2].IsCanceled && queue.Tasks[3].IsCanceled, "Last tasks canceled");
queue.ClearUpTasks();
queue.Dispose();
}
public void ClearUp_Tasks_TasksNotFinishedTest()
{
FifoTaskQueue queue = CreateTaskQueue();
queue.Run(() =>
{
Task.Delay(5000).Wait();
});
queue.Run(() =>
{
Task.Delay(2000).Wait();
});
queue.Run(() =>
{
Task.Delay(2000).Wait();
});
queue.ClearUpTasks();
Assert.IsTrue(queue.Tasks[0].IsCompleted == false &&
queue.Tasks[1].IsCompleted == false &&
queue.Tasks[2].IsCompleted == false);
queue.Dispose();
}
public async Task Run_DownloadSyncTest()
{
FifoTaskQueue queue = CreateTaskQueue();
bool downloaded1 = false;
bool downloaded2 = false;
queue.Run(() =>
{
using (Task <bool> downloading = Download(1000))
{
downloading.Wait();
downloaded1 = downloading.Result;
}
Assert.IsTrue(downloaded1, "First async action performed.");
});
queue.Run(() =>
{
using (Task <bool> downloading = Download(1000))
{
downloading.Wait();
downloaded2 = downloading.Result;
}
Assert.IsTrue(downloaded2, "Second async action performed.");
});
queue.Run(() =>
{
Assert.IsTrue(downloaded1 == true && downloaded2 == true);
});
bool done = await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
//wait for download finalization at async methods.
Assert.IsTrue(queue.Tasks[0].IsCompleted, "all task completed");
Assert.IsTrue(queue.Tasks[1].IsCompleted, "all task completed");
Assert.IsTrue(queue.Tasks[2].IsCompleted, "all task completed");
Assert.IsTrue(downloaded1, "First Async. Task performed.");
Assert.IsTrue(downloaded2, "Second Async. Task performed.");
queue.Dispose();
}
public async Task CompleteTasks_Called_After_Each_TaskTest()
{
FifoTaskQueue queue = CreateTaskQueue();
queue.Run(() => {
Task.Delay(5000, queue.CancellationToken).Wait();
});
await queue.CancelAfter(2000, EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
queue.Run(() => { });
await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
queue.Run(() => { });
await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
queue.Run(() => { });
await queue.ObserveCompletation(EXCLUDE_TASK_CLEANUP_AFTER_FINALIZATION);
Assert.IsTrue(queue.Tasks[0].IsFaulted, "First Task Faulted");
Assert.IsTrue(queue.Tasks[1].IsCanceled, "second Task completed");
Assert.IsTrue(queue.Tasks[2].IsCanceled && queue.Tasks[3].IsCanceled, "Last two completed");
queue.ClearUpTasks();
queue.Dispose();
}
