public void TestSingleParamById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "0FE51C65-C0F7-4BC0-9CD1-9BF8CC98AB3D";
manager.RegisterTaskType(typeof(MyTask2), new TaskSettings(guid));
manager.EnqueueSingleTask <Task2Parameter>(new Guid(guid), new Task2Parameter()
{
Value = 456
});
MyTask2.ParamValue = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTask2.ParamValue == 456);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestRecurrentTask()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings("C4A0CCD2-A04D-4E59-8346-2A8AA4E2EA0E"));
MyTaskRecurrent1.TaskExecuted = 0;
var recurrentId = manager.EnqueueRecurrentTask <MyTaskRecurrent1>(1000);
int count = 0;
manager.SubscribeToListener(() =>
{
count++;
if (count > 3)
{
manager.StopListener();
}
else
{
Thread.Sleep(1000);
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskRecurrent1.TaskExecuted > 1, $"Task should've executed more than once: {MyTaskRecurrent1.TaskExecuted}");
Assert.True(manager.LatestListenerException == null, "No exception exptected");
}
}
public void TestSingleParam()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTask2), new TaskSettings("8DCB87AA-FAE8-4E03-9A66-533705C4803C"));
manager.EnqueueSingleTask <MyTask2, Task2Parameter>(new Task2Parameter()
{
Value = 456
});
MyTask2.ParamValue = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTask2.ParamValue == 456);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestSingleException()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskException), new TaskSettings("FEB9BB14-1BE7-42A7-8E02-D2175F2BD51F"));
MyTaskException.TaskExecuted = 0;
var taskId = manager.EnqueueSingleTask <MyTaskException>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.False(manager.IsListenning);
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTaskException.TaskExecuted == 1);
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void TestSingleById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "139E764E-AA4D-4B99-9FF1-603C743ECC32";
manager.RegisterTaskType(typeof(MyTask1), new TaskSettings(guid));
MyTask1.TaskExecuted = 0;
manager.EnqueueSingleTask(new Guid(guid));
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
TaskHelper.WaitSafeSync(() => manager.StartListener(delay: 100));
manager.WaitTillListenerStops();
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTask1.TaskExecuted == 1);
}
}
public void TestSingleAndRecurrent()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings("BF168DA8-3D80-429E-93AF-0958E80128A1"));
manager.EnqueueRecurrentTask <MyTaskRecurrent1>(1000);
manager.EnqueueSingleTask <MyTaskRecurrent1>();
MyTaskRecurrent1.TaskExecuted = 0;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskRecurrent1.TaskExecuted > 0);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestTypeNotRegisteredWithManager()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var otherManager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.StartListener();
otherManager.RegisterTaskType(typeof(MyTask1), new TaskSettings("41CE95B5-A7DC-4A9B-A0C2-CA441639BF5E"));
var taskId = otherManager.EnqueueSingleTask <MyTask1>();
//The second manager is not listenning yet.
//Waits for the first manager to pick up a non-registered task.
Thread.Sleep(3000);
Assert.True(manager.IsListenning);
manager.StopListener();
otherManager.StopListener();
Assert.True(manager.RemoveSingleTask(taskId));
Assert.True(manager.LatestListenerException == null);
Assert.True(otherManager.LatestListenerException == null);
}
}
public void TestSingle()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTask1), new TaskSettings("D591C9C1-F034-4151-993D-AB2A76374994"));
MyTask1.TaskExecuted = 0;
var taskId = manager.EnqueueSingleTask <MyTask1>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
TaskHelper.WaitSafeSync(() => manager.StartListener(delay: 100));
manager.WaitTillListenerStops();
Assert.False(manager.IsListenning);
Assert.True(manager.LatestListenerException == null);
Assert.True(MyTask1.TaskExecuted == 1);
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void TestAbandonedTask()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager2 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskLongTask),
new TaskSettings("7EBA6938-15A7-4C9F-9CA2-5DC3C5EFE6EA")
{
AliveCycle = new TimeSpan(Convert.ToInt64(TimeSpan.TicksPerSecond * 2.5))
});
var taskId = manager.EnqueueSingleTask <MyTaskLongTask>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 0)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.CompletedAborted, "Status should be CompletedAborted");
//Fake running status
task.SetStatus(SingleTaskStatus.Running);
task.LockedUntil = DateTime.UtcNow.AddDays(-1); // Ideally should use database-based clock
db.SaveChanges();
}
tickCount = 0;
manager2.SubscribeToListener(() => { if (tickCount++ > 0)
{
manager2.StopListener();
}
});
manager2.StartListener();
manager2.WaitTillListenerStops();
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.CompletedAbandoned, "Status should be CompletedAbandoned");
}
}
}
public void FactoryShouldCreateTaskManagersWithTheGivenSize(int size)
{
var taskManager = TaskManagerFactory.CreateTaskManager(taskManagerSize: size);
for (var i = 0; i < size; i++)
{
taskManager.Add(new ProcessDto(Priority.Low));
}
var isAdded = taskManager.Add(new ProcessDto(Priority.Low));
Assert.Null(isAdded);
}
public void FactoryShouldCreateTaskManagersWithDefaultSize()
{
var taskManager = TaskManagerFactory.CreateTaskManager();
for (var i = 0; i < TaskManagerFactory.TaskManagerSize; i++)
{
taskManager.Add(new ProcessDto(Priority.Low));
}
var isAdded = taskManager.Add(new ProcessDto(Priority.Low));
Assert.Null(isAdded);
}
private void KillShouldRemoveTheProcessFromTaskManager()
{
var taskManager = TaskManagerFactory.CreateTaskManager(taskManagerSize: 2);
var process = taskManager.Add(new ProcessDto(Priority.Low));
var killed = taskManager.Kill(process.PID);
Assert.True(killed);
var processlist = taskManager.List();
Assert.Null(processlist.FirstOrDefault(m => m.PID == process.PID));
}
public void TaskManagerOverFlow()
{
var taskManager = TaskManagerFactory.CreateTaskManager(taskManagerSize: 2);
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Low));
var isAdded = taskManager.Add(new ProcessDto(Priority.Low));
Assert.Null(isAdded);
var itemCount = taskManager.List().ToList().Count;
Assert.True(itemCount == 2);
}
public void FifoTaskManagerOverFlow()
{
var taskManager = TaskManagerFactory.CreateTaskManager(CustomerName, 2);
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Low));
var isAdded = taskManager.Add(new ProcessDto(Priority.Low));
Assert.NotNull(isAdded);
var itemCount = taskManager.List().ToList().Count;
Assert.True(2 == itemCount);
}
public void TaskListShouldBeOrderedByCreationDate()
{
var taskManager = TaskManagerFactory.CreateTaskManager();
var p1 = taskManager.Add(new ProcessDto(Priority.Low));
var p2 = taskManager.Add(new ProcessDto(Priority.High));
var p3 = taskManager.Add(new ProcessDto(Priority.Medium));
var items = taskManager.List().ToList();
Assert.Equal(items[0].PID, p1.PID);
Assert.Equal(items[1].PID, p2.PID);
Assert.Equal(items[2].PID, p3.PID);
}
public void TaskListShouldBeOrderedByPriority()
{
var taskManager = TaskManagerFactory.CreateTaskManager();
var pLow = taskManager.Add(new ProcessDto(Priority.Low));
var pHigh = taskManager.Add(new ProcessDto(Priority.High));
var pMedium = taskManager.Add(new ProcessDto(Priority.Medium));
var items = taskManager.List(m => m.Priority).ToList();
Assert.Equal(items[0].PID, pLow.PID);
Assert.Equal(items[1].PID, pMedium.PID);
Assert.Equal(items[2].PID, pHigh.PID);
}
public void TestForceCancelTaskAndRecovery()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 1 hours (till force cancelled)
var options = new TaskManagerOptions()
{
MainLoopWait = 100, MaxWorkerThreads = 1
};
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), options))
{
manager.RegisterTaskType(typeof(MyTaskLongTask),
new TaskSettings("CBC68EFE-532D-44C7-87D8-3443636F6425")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
var longTaskId = manager.EnqueueSingleTask <MyTaskLongTask>();
manager.StartListener();
Thread.Sleep(500);
manager.RegisterTaskType(typeof(MyTask), new TaskSettings("BC54E6F5-9EDF-48C2-8765-269BCC472DDF"));
var taskId = manager.EnqueueSingleTask <MyTask>();
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 2)
{
manager.StopListener();
}
});
manager.WaitTillListenerStops();
Assert.True(manager.LatestListenerException == null);
using (var db = TestDbContext.Create())
{
var longTask = db.SingleTasks.Where(t => t.Id == longTaskId).FirstOrDefault();
Assert.True(longTask.Status == SingleTaskStatus.CompletedAborted);
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.True(task.Status == SingleTaskStatus.Completed);
}
}
}
public void PriorityQueueWithLowPriority()
{
var taskManager = TaskManagerFactory.CreateTaskManager(CustomerName, 2);
var p1 = new ProcessDto(Priority.Low);
taskManager.Add(p1);
taskManager.Add(new ProcessDto(Priority.Low));
var isAdded = taskManager.Add(new ProcessDto(Priority.Medium));
Assert.NotNull(isAdded);
var processList = taskManager.List();
Assert.Null(processList.FirstOrDefault(m => m.PID == p1.PID));
}
public void TestAutoRenewLock()
{
// MyTaskAutoRenewLock
// AliveCycle - 1 sec
// LockCycle - 2 secs
// Runs for - 3 secs
// Task Lock auto-renewed every 1 seconds
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskAutoRenewLock),
new TaskSettings("1BE679EB-D6D6-4239-90FB-5116C031762F")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
var taskId = manager.EnqueueSingleTask <MyTaskAutoRenewLock>();
MyTaskAutoRenewLock.TaskStarted = false;
MyTaskAutoRenewLock.CancelationRequested = false;
MyTaskAutoRenewLock.ProcessedAllRecords = false;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 3)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskAutoRenewLock.TaskStarted, "TaskStarted should be true");
Assert.False(MyTaskAutoRenewLock.CancelationRequested, "CancelationRequested should be false");
using (var db = TestDbContext.Create())
{
var task = db.SingleTasks.Where(t => t.Id == taskId).FirstOrDefault();
Assert.Equal(SingleTaskStatus.Completed, task.Status);
}
Assert.True(MyTaskAutoRenewLock.ProcessedAllRecords, "ProcessedAllRecords should be true");
Assert.True(manager.LatestListenerException == null, "LatestListenerException should be null");
}
}
private static void Main(string[] args)
{
Console.WriteLine("Hi, this is the task manager!");
try
{
Console.WriteLine("Please select Customer Type: F for Fifo / P for Priority / D for Default");
var customerType = Console.ReadLine();
var taskManager = TaskManagerFactory.CreateTaskManager(customerType);
PrintMenu();
var command = Console.ReadLine()?.ToUpper();
while (command != "E")
{
switch (command)
{
case "A":
NewProcess(taskManager);
break;
case "L":
ListProcesses(taskManager);
break;
case "K":
KillProcess(taskManager);
break;
default:
Console.WriteLine("Wrong command.");
break;
}
PrintMenu();
command = Console.ReadLine();
}
Console.WriteLine("Bye!");
Environment.Exit(0);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private void KillAllShouldRemoveAllTheTaskFromTaskManager()
{
var taskManager = TaskManagerFactory.CreateTaskManager(taskManagerSize: 6);
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Medium));
taskManager.Add(new ProcessDto(Priority.Medium));
taskManager.Add(new ProcessDto(Priority.High));
taskManager.Add(new ProcessDto(Priority.High));
var killed = taskManager.KillAll();
Assert.True(killed);
var processlist = taskManager.List();
Assert.False(processlist.Any());
}
private void KillByPriorityShouldRemoveTheProcessFromTaskManager(Priority priority)
{
var taskManager = TaskManagerFactory.CreateTaskManager(taskManagerSize: 6);
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Low));
taskManager.Add(new ProcessDto(Priority.Medium));
taskManager.Add(new ProcessDto(Priority.Medium));
taskManager.Add(new ProcessDto(Priority.High));
taskManager.Add(new ProcessDto(Priority.High));
var killed = taskManager.KillByPriority(priority);
Assert.True(killed);
var processlist = taskManager.List();
Assert.Null(processlist.FirstOrDefault(m => m.Priority == priority));
}
public void PriorityQueueWithHighPriority()
{
var taskManager = TaskManagerFactory.CreateTaskManager(CustomerName, 2);
var pLowOld = new ProcessDto(Priority.Low);
var pHigh = new ProcessDto(Priority.High);
var pMedium = new ProcessDto(Priority.Medium);
var pLowNew = new ProcessDto(Priority.Low);
taskManager.Add(pLowOld);
taskManager.Add(pHigh);
taskManager.Add(pLowNew);
var isAdded = taskManager.Add(pMedium);
Assert.NotNull(isAdded);
var processList = taskManager.List();
Assert.Null(processList.FirstOrDefault(m => m.PID == pLowOld.PID));
}
public void FifoTaskManagerOverFlowOldestWillBeKilled()
{
var taskManager = TaskManagerFactory.CreateTaskManager(CustomerName, 2);
var p1 = new ProcessDto(Priority.Low);
var p2 = new ProcessDto(Priority.Low);
var p3 = new ProcessDto(Priority.Low);
taskManager.Add(p1);
taskManager.Add(p2);
taskManager.Add(p3);
var processList = taskManager.List(m => m.CreateDate);
Assert.Null(processList.FirstOrDefault(m => m.PID == p1.PID));
var p4 = new ProcessDto(Priority.Low);
taskManager.Add(p4);
processList = taskManager.List(m => m.CreateDate);
Assert.Null(processList.FirstOrDefault(m => m.PID == p2.PID));
}
public void TestAutoCancelTask()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 3 secs
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskAutoCancelTask),
new TaskSettings("73793DDA-CE7A-4B16-A751-4F90B5799AFA")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
manager.EnqueueSingleTask <MyTaskAutoCancelTask>();
MyTaskAutoCancelTask.CancelationRequested = false;
MyTaskAutoCancelTask.ProcessedAllRecords = null;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskAutoCancelTask.CancelationRequested == true);
Assert.True(MyTaskAutoCancelTask.ProcessedAllRecords == false);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestForceCancelTask()
{
// MyTaskAutoCancelTask
// AliveCycle = 1 sec
// LockCycle - 2 secs
// Runs for - 1 hours (till force cancelled)
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
manager.RegisterTaskType(typeof(MyTaskForceCancelTask),
new TaskSettings("52BB4E12-3237-4B89-885E-ECEC41C56DE5")
{
AliveCycle = new TimeSpan(TimeSpan.TicksPerSecond)
});
manager.EnqueueSingleTask <MyTaskForceCancelTask>();
MyTaskForceCancelTask.ExecutedTillEnd = null;
MyTaskForceCancelTask.CancelationRequested = false;
int tickCount = 0;
manager.SubscribeToListener(() => { if (tickCount++ > 1)
{
manager.StopListener();
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Assert.True(MyTaskForceCancelTask.CancelationRequested == true);
Assert.True(MyTaskForceCancelTask.ExecutedTillEnd == false);
Assert.True(manager.LatestListenerException == null);
}
}
public void TestRecurrentTaskById()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var guid = "FDC1CFA0-197B-4548-A5D6-2A1183472C37";
manager.RegisterTaskType(typeof(MyTaskRecurrent1), new TaskSettings(guid));
MyTaskRecurrent1.TaskExecuted = 0;
var recurrentId = manager.EnqueueRecurrentTask(new Guid(guid), 1000);
int count = 0;
manager.SubscribeToListener(() =>
{
count++;
if (count > 3)
{
manager.StopListener();
}
else
{
Thread.Sleep(1000);
}
});
manager.StartListener();
manager.WaitTillListenerStops();
Console.AppendLine($"Recurrent Task executed {MyTaskRecurrent1.TaskExecuted} times.");
Assert.True(MyTaskRecurrent1.TaskExecuted > 1, "Task should've executed more than once");
Assert.True(manager.LatestListenerException == null, "No exception exptected");
}
}
public void MultipleManagers()
{
using (var manager = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager2 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
using (var manager3 = TaskManagerFactory.Create(() => TestDbContext.Create(), new TaskManagerOptions()
{
MainLoopWait = 100
}))
{
var TOTAL_TASK_COUNT = 80;
manager.StartListener();
manager2.StartListener();
manager3.StartListener();
Thread.Sleep(300);
var guid = "2A71134F-AED4-47D5-AB3C-69B3EBC87C00";
manager.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
manager2.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
manager3.RegisterTaskType(typeof(MyTask), new TaskSettings(guid));
MyTask.TaskExecuted = 0;
MyTask.elements = new List <int?>();
MyTask.duplicate = new List <int?>();
var taskIds = new List <int>();
for (int i = 0; i < TOTAL_TASK_COUNT; i++)
{
taskIds.Add(manager.EnqueueSingleTask <MyTask, int?>(i));
}
using (var db = TestDbContext.Create())
{
while (db.SingleTasks.Where(t => taskIds.Contains(t.Id)).Count(t => t.Status == SingleTaskStatus.Scheduled) > 0)
{
Thread.Sleep(333);
}
}
Assert.True(manager.IsListenning);
Assert.True(manager2.IsListenning);
Assert.True(manager3.IsListenning);
manager.StopListener(true);
manager2.StopListener(true);
manager3.StopListener(true);
Assert.True(MyTask.TaskExecuted == TOTAL_TASK_COUNT);
Assert.True(MyTask.elements.Count() == TOTAL_TASK_COUNT);
Assert.True(MyTask.duplicate.Count() == 0);
Assert.True(manager.TasksExecutedCount > 0);
Assert.True(manager2.TasksExecutedCount > 0);
Assert.True(manager3.TasksExecutedCount > 0);
Console.AppendLine($"manager 1: {manager.TasksExecutedCount}");
Console.AppendLine($"manager 2: {manager2.TasksExecutedCount}");
Console.AppendLine($"manager 3: {manager3.TasksExecutedCount}");
Assert.Equal(TOTAL_TASK_COUNT, manager.TasksExecutedCount + manager2.TasksExecutedCount + manager3.TasksExecutedCount);
}
}
public void FactoryShouldCreateTaskManagersBasedOnCustomer(string customer, Type typeOfTaskManager)
{
var taskManager = TaskManagerFactory.CreateTaskManager(customer);
Assert.Equal(typeOfTaskManager, taskManager.GetType());
}
