namespace TimeoutFunctions.Tests
{
using System;
using System.Collections.Generic;
using NUnit.Framework;
using TimeoutFunctions;
using System.Threading;
using System.Diagnostics;
using System.IO;
[TestFixture]
public class TimeoutProcessTests
{
[Test]
public void CanTimeoutRunningProcess() {
WaitCallback waitCallBack = GetLongRunningProcess();
TimeoutProcess timeoutProcess = new TimeoutProcess();
bool status = timeoutProcess.Start(null, TimeSpan.FromSeconds(2), waitCallBack);
Assert.That(!status, "Process is not timing out");
}
[Test]
public void CanFinishRunningProcessWithMoreTimeoutLimit() {
WaitCallback waitCallBack = GetAFastRunningProcess();
TimeoutProcess timeoutProcess = new TimeoutProcess();
bool status = timeoutProcess.Start(null, TimeSpan.FromSeconds(30), waitCallBack);
Assert.That(status, "Process is not completing");
}
[Test]
public void CanTimeoutBlockedProcess() {
WaitCallback waitCallBack = GetBlockedProcess(5000);
TimeoutProcess timeoutProcess = new TimeoutProcess();
bool success = timeoutProcess.Start(null, TimeSpan.FromSeconds(2), waitCallBack);
Assert.That(!success);
}
EventWaitHandle nUnitHandle = new AutoResetEvent(false);
[Test]
public void AsyncProcessTimeoutTest() {
WaitCallback waitCallBack = GetLongRunningProcess();
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += timeoutProcess_AsyncProcessTimedout;
timeoutProcess.StartAsync(null, TimeSpan.FromSeconds(2), waitCallBack);
nUnitHandle.WaitOne();
}
void timeoutProcess_AsyncProcessTimedout(object sender, AsyncProcessEventArgs e) {
Assert.That(!e.HasProcessCompleted, "Async operation not timed out");
Assert.AreEqual(false, e.IsThreadRunning, "Operation timedout, but thread still running");
nUnitHandle.Set();
}
EventWaitHandle[] waitHandles = null;
[Test]
public void MultipleAsyncProcessTimingout() {
const int waitHandleCount = 10;
waitHandles = new EventWaitHandle[waitHandleCount];
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += timeoutProcess_MultipleAsyncProcessTimedout;
for (int i = 0; i < waitHandleCount; i++) {
waitHandles[i] = new AutoResetEvent(false);
WaitCallback waitCallBack = GetLongRunningProcess();
timeoutProcess.StartAsync(i, TimeSpan.FromSeconds(2), waitCallBack);
}
Assert.AreEqual(10, timeoutProcess.AsyncProcessCount, "Process count is not matching");
Assert.That(timeoutProcess.IsAsyncProcessExecuting, "AsyncProcessExecuting flag is setting");
WaitHandle.WaitAll(waitHandles);
}
void timeoutProcess_MultipleAsyncProcessTimedout(object sender, AsyncProcessEventArgs e) {
int processIndex = (int)e.UserState;
Assert.That(!e.HasProcessCompleted, string.Format("Async operation {0} not timed out", processIndex));
waitHandles[processIndex].Set();
}
[Test]
public void MultipleAsyncProcessCompletedSuccessfully() {
const int waitHandleCount = 10;
waitHandles = new EventWaitHandle[waitHandleCount];
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += timeoutProcess_MultipleAsyncProcessCompleted;
for (int i = 0; i < waitHandleCount; i++) {
waitHandles[i] = new AutoResetEvent(false);
WaitCallback waitCallBack = GetAFastRunningProcess();
timeoutProcess.StartAsync(i, TimeSpan.FromMinutes(1), waitCallBack);
}
WaitHandle.WaitAll(waitHandles);
Assert.AreEqual(0, timeoutProcess.AsyncProcessCount, "Async process count is not matching");
Assert.That(!timeoutProcess.IsAsyncProcessExecuting, "Async process executing flag is not resetting");
}
void timeoutProcess_MultipleAsyncProcessCompleted(object sender, AsyncProcessEventArgs e) {
int processIndex = (int)e.UserState;
Assert.That(e.HasProcessCompleted, string.Format("Async operation {0} not completed", processIndex));
waitHandles[processIndex].Set();
}
[Test]
public void AsyncProcessCountComingCorrectly() {
TimeoutProcess process = new TimeoutProcess();
for (int i = 0; i < 10; i++) {
WaitCallback waitCallBack = GetLongRunningProcess();
process.StartAsync(null, TimeSpan.FromMinutes(1), waitCallBack);
}
Assert.AreEqual(10, process.AsyncProcessCount, "Async process count is not matching");
}
[Test]
public void AsyncProcessCompletionTestWithAValidObject() {
List<int> data = new List<int>();
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += delegate(object sender, AsyncProcessEventArgs args)
{
Assert.AreEqual(true, args.HasProcessCompleted);
nUnitHandle.Set();
};
WaitCallback callBack = delegate(object obj)
{
Thread.Sleep(2000);
for (int i = 0; i < 2000; i++)
data.Add(i);
};
timeoutProcess.StartAsync(null, TimeSpan.FromMinutes(1), callBack);
nUnitHandle.WaitOne();
Assert.AreEqual(0, timeoutProcess.AsyncProcessCount, "Async process not ended");
Assert.AreEqual(2000, data.Count, "Invalid data count detected");
}
[Test]
public void AsyncProcessTimeoutTestWithAValidObject() {
List<int> data = new List<int>();
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += delegate(object sender, AsyncProcessEventArgs args)
{
nUnitHandle.Set();
Assert.AreEqual(false, args.IsThreadRunning, "Worker still running");
};
WaitCallback callBack = delegate(object obj)
{
for (int i = 0; i < 2000000; i++) {
data.Add(i);
Thread.Sleep(100);
}
};
timeoutProcess.StartAsync(null, TimeSpan.FromSeconds(1), callBack);
nUnitHandle.WaitOne();
Assert.AreEqual(0, timeoutProcess.AsyncProcessCount, "Async process not ended");
Assert.AreNotEqual(2000000, data.Count, "Invalid data count detected");
}
[Test]
public void ShouldTimeoutEvenUserHandlesThreadExceptions() {
WaitCallback callBack = delegate(object obj)
{
for (int i = 0; i < 200000; i++) {
try {
Debug.WriteLine(i);
}
catch (ThreadAbortException) {
// do nothing
}
catch (ThreadInterruptedException) {
// do nothing
}
}
};
TimeoutProcess timeoutProcess = new TimeoutProcess();
bool status = timeoutProcess.Start(null, TimeSpan.FromSeconds(1), callBack);
Assert.AreEqual(false, status, "User handled thread exception process not timing out");
}
[Test]
public void IsThreadRunningComingTRUE() {
WaitCallback callBack = delegate(object obj)
{
for (int i = 0; i < 200000; i++) {
try {
Debug.WriteLine(i);
}
catch (ThreadAbortException) {
// don't allow to reset
Thread.ResetAbort();
}
}
};
TimeoutProcess timeoutProcess = new TimeoutProcess();
timeoutProcess.AsyncProcessCompleted += delegate(object sender, AsyncProcessEventArgs args)
{
Assert.AreEqual(true, args.IsThreadRunning, "Thread running flag is not set");
Assert.AreEqual(true, args.AsyncWorker != null, "Async worker is NULL");
nUnitHandle.Set();
};
timeoutProcess.StartAsync(null, TimeSpan.FromSeconds(1), callBack);
nUnitHandle.WaitOne();
}
WaitCallback GetLongRunningProcess() {
return delegate(object obj)
{
for (int i = 0; i < 200000; i++) {
Debug.WriteLine(i);
}
};
}
WaitCallback GetBlockedProcess(int duration) {
return delegate(object obj)
{
Thread.Sleep(duration);
};
}
WaitCallback GetAFastRunningProcess() {
return delegate(object obj)
{
for (int i = 0; i < 200; i++) {
Debug.WriteLine(i);
}
};
}
}
}