public void OneThreadManyTasksTest(int taskCount) { var pool = new MyThreadPool(1); var tasks = new List <IMyTask <int> >(); var idBag = new ConcurrentBag <int>(); for (var i = 0; i < taskCount; ++i) { var localIndex = i; tasks.Add(pool.QueueTask(() => { idBag.Add(Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); return(localIndex); })); } for (var i = 0; i < taskCount; ++i) { Assert.AreEqual(i, tasks[i].Result); } Assert.AreEqual(1, idBag.Distinct().Count()); }
public void ContinueWithShutdownTest(int threadCount) { var pool = new MyThreadPool(threadCount); var tasks = new IMyTask <int> [threadCount + 10]; var resetEvent = new ManualResetEvent(false); tasks[0] = pool.QueueTask(() => { resetEvent.WaitOne(); return(1); }); for (var i = 1; i < tasks.Length; ++i) { tasks[i] = tasks[i - 1].ContinueWith((j) => { return(++j); }); } pool.Shutdown(); resetEvent.Set(); for (var i = 1; i < tasks.Length; ++i) { Assert.Throws <ThreadPoolShutdownException>(() => _ = tasks[i].Result); Assert.IsFalse(tasks[i].IsCompleted); } while (pool.ActiveThreadCount != 0) { ; } }
public void ContinueWithTest([Values(1, 3, 5, 10)] int threadCount, [Values(5, 10, 20)] int taskCount) { var pool = new MyThreadPool(threadCount); var tasks = new IMyTask <int> [taskCount]; var counters = new int[taskCount]; var resetEvent = new ManualResetEvent(false); tasks[0] = pool.QueueTask(() => { resetEvent.WaitOne(); Interlocked.Increment(ref counters[0]); return(1); }); for (var i = 1; i < taskCount; ++i) { var localIndex = i; tasks[i] = tasks[i - 1].ContinueWith((j) => { resetEvent.WaitOne(); Interlocked.Increment(ref counters[localIndex]); return(j * 2); }); } resetEvent.Set(); for (var i = 0; i < taskCount; ++i) { Assert.AreEqual(tasks[i].Result, Math.Pow(2, i)); Assert.AreEqual(1, counters[i]); } }
public void ConcurrentResultTest(int threadCount) { var tasks = new Task <int> [threadCount]; var pool = new MyThreadPool(1); var resetEvent = new ManualResetEvent(false); var myTask = pool.QueueTask(() => { Thread.Sleep(1000); return(0); }); for (var i = 0; i < tasks.Count(); ++i) { tasks[i] = new Task <int>(() => { resetEvent.WaitOne(); return(myTask.Result); }); tasks[i].Start(); } resetEvent.Set(); foreach (var current in tasks) { Assert.AreEqual(0, current.Result); } }
public void IsCompletedTest(int threadCount) { var pool = new MyThreadPool(threadCount); var tasks = new List <IMyTask <int> >(); var resetEvent = new ManualResetEvent(false); for (var i = 0; i < threadCount; ++i) { var localIndex = i; tasks.Add(pool.QueueTask(() => { resetEvent.WaitOne(); return(0); })); } foreach (var task in tasks) { Assert.IsFalse(task.IsCompleted); } resetEvent.Set(); foreach (var task in tasks) { Assert.AreEqual(0, task.Result); Assert.IsTrue(task.IsCompleted); } }
public void MultipleContinueWithTest() { var pool = new MyThreadPool(3); var resetEvent1 = new ManualResetEvent(false); var resetEvent2 = new ManualResetEvent(false); var firstTask = pool.QueueTask(() => { resetEvent1.WaitOne(); return(100); }); var intTask1 = firstTask.ContinueWith((j) => { resetEvent2.WaitOne(); return(j + 100); }); var intTask2 = firstTask.ContinueWith((j) => { resetEvent2.WaitOne(); return(j + 200); }); var stringTask = firstTask.ContinueWith((j) => { resetEvent2.WaitOne(); return(j.ToString()); }); var boolTask = firstTask.ContinueWith((j) => { resetEvent2.WaitOne(); return(j > 0); }); resetEvent1.Set(); Assert.AreEqual(100, firstTask.Result); Assert.IsFalse(intTask1.IsCompleted); Assert.IsFalse(intTask2.IsCompleted); Assert.IsFalse(stringTask.IsCompleted); Assert.IsFalse(boolTask.IsCompleted); resetEvent2.Set(); Assert.AreEqual(200, intTask1.Result); Assert.AreEqual(300, intTask2.Result); Assert.AreEqual("100", stringTask.Result); Assert.AreEqual(true, boolTask.Result); Assert.IsTrue(intTask1.IsCompleted); Assert.IsTrue(intTask2.IsCompleted); Assert.IsTrue(stringTask.IsCompleted); Assert.IsTrue(boolTask.IsCompleted); }
public void ShutdownTest(int threadCount) { var pool = new MyThreadPool(threadCount); var tasks = new List <IMyTask <int> >(); var resetEvent = new ManualResetEvent(false); var counter = 0; for (var i = 0; i < threadCount + 10; ++i) { tasks.Add(pool.QueueTask(() => { resetEvent.WaitOne(); Interlocked.Increment(ref counter); return(0); })); } Thread.Sleep(1000); pool.Shutdown(); resetEvent.Set(); Thread.Sleep(1000); Assert.AreEqual(threadCount, counter); for (var i = 0; i < threadCount; ++i) { Assert.AreEqual(0, tasks[i].Result); Assert.IsTrue(tasks[i].IsCompleted); } for (var i = threadCount; i < threadCount + 10; ++i) { Assert.Throws <ThreadPoolShutdownException>(() => _ = tasks[i].Result); Assert.IsFalse(tasks[i].IsCompleted); } Assert.Throws <ThreadPoolShutdownException>(() => pool.QueueTask(() => 0)); Assert.Throws <ThreadPoolShutdownException>(() => tasks[0].ContinueWith((i) => i * 2)); while (pool.ActiveThreadCount != 0) { ; } }
public void AggregateExceptionTest() { var pool = new MyThreadPool(3); var task1 = pool.QueueTask(() => 0); var task2 = task1.ContinueWith((j) => 1 / j); var task3 = task2.ContinueWith((j) => j.ToString()); Assert.Throws <AggregateException>(() => _ = task2.Result); Assert.Throws <AggregateException>(() => _ = task3.Result); }
public void SimpleConcurrentCalculationTest(int threadCount) { var pool = new MyThreadPool(threadCount); var tasks = new List <IMyTask <int> >(); for (var i = 0; i < threadCount; ++i) { var localIndex = i; tasks.Add(pool.QueueTask(() => { Thread.Sleep(1000); return(localIndex); })); } for (var i = 0; i < threadCount; ++i) { Assert.AreEqual(i, tasks[i].Result); } }
public void ThreadCountTest(int threadCount) { var pool = new MyThreadPool(threadCount); var idBag = new ConcurrentBag <int>(); var handles = new WaitHandle[threadCount]; for (var i = 0; i < threadCount; ++i) { handles[i] = new AutoResetEvent(false); var localIndex = i; pool.QueueTask(() => { idBag.Add(Thread.CurrentThread.ManagedThreadId); Thread.Sleep(1000); var resetEvent = (AutoResetEvent)handles[localIndex]; resetEvent.Set(); return(0); }); } WaitHandle.WaitAll(handles); Assert.AreEqual(idBag.Count, idBag.Distinct().Count()); }
public void NumberOfMaximumThreadsIsRight() { var set = new HashSet <string>(); for (var i = 0; i < 10; ++i) { threadPool.QueueTask(() => { set.Add(Thread.CurrentThread.Name); Thread.Sleep(1000); return(5); }); } Thread.Sleep(2000); threadPool.Shutdown(); Assert.IsTrue(set.Count >= threadPool.NumberOfThreads); }