public void TestQueueGotEmpty()
{
_jobCount = 0;
AsyncProcessor proc = new AsyncProcessor();
using ( proc )
{
proc.QueueGotEmpty += new EventHandler(proc_QueueGotEmpty);
proc.ThreadFinished += new EventHandler(proc_ThreadStarted1);
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new EnumeratorJob(3, 200));
Thread.Sleep(300);
if (_jobCount != 3)
{
throw new Exception("TestQueueGotEmpty() failed (first check). _jobCount = " + _jobCount);
}
Thread.Sleep(200);
if (_jobCount != 4)
{
throw new Exception("TestQueueGotEmpty() failed (second check). _jobCount = " + _jobCount);
}
Thread.Sleep(300);
if (_jobCount != 8)
{
throw new Exception("TestQueueGotEmpty() failed (third check). _jobCount = " + _jobCount);
}
}
if (_jobCount != 4)
{
throw new Exception("TestQueueGotEmpty() failed (final check). _jobCount = " + _jobCount);
}
}
public void TestAsyncProcessorEvents()
{
_jobCount = 0;
AsyncProcessor proc = new AsyncProcessor(false);
using ( proc )
{
proc.ThreadStarted += new EventHandler(proc_ThreadStarted);
proc.ThreadStarted += new EventHandler(proc_ThreadStarted1);
proc.ThreadStarted += new EventHandler(proc_ThreadStarted2);
proc.ThreadFinished += new EventHandler(proc_ThreadStarted);
proc.ThreadFinished += new EventHandler(proc_ThreadStarted1);
proc.FillingEmptyQueue += new EventHandler(proc_FillingEmptyQueue);
proc.QueueGotEmpty += new EventHandler(proc_QueueGotEmpty);
proc.QueueGotEmpty += new EventHandler(proc_QueueGotEmpty1);
proc.JobStarting += new EventHandler(proc_JobStarting);
proc.JobFinished += new EventHandler(proc_JobFinished);
proc.JobQueued += new JetBrains.Omea.AsyncProcessing.AsyncProcessor.JobDelegate(proc_JobQueued);
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new SleepJob(0));
proc.QueueEndOfWork();
proc.EmployCurrentThread();
}
if (_jobCount != 0)
{
throw new Exception("TestAsyncProcessorEvents() failed. _jobCount = " + _jobCount);
}
}
public void TestReenteringJobMixedWithOrdinaryJobs()
{
_jobCount = 0;
AsyncProcessor processor = new AsyncProcessor(false);
using ( processor )
{
const int total = 10;
processor.QueueJob(JobPriority.AboveNormal, new SleepJob(0));
processor.QueueJob(JobPriority.AboveNormal, new SleepJob(0));
processor.QueueJob(JobPriority.AboveNormal, new SleepJob(0));
processor.QueueJob(JobPriority.AboveNormal, new SleepJob(0));
processor.QueueJob(new GroupJob(total, total));
processor.QueueJob(new SleepJob(300));
processor.QueueJob(new SleepJob(0));
processor.QueueJob(new SleepJob(0));
processor.QueueJob(JobPriority.Immediate, new SleepJob(0));
processor.StartThread();
Thread.Sleep(200);
if (_jobCount != total + 7)
{
throw new Exception("TestReenteringJobMixedWithOrdinaryJobs() failed (first check). _jobCount = " + _jobCount);
}
Thread.Sleep(150);
if (_jobCount != total + 11)
{
throw new Exception("TestReenteringJobMixedWithOrdinaryJobs() failed (second check). _jobCount = " + _jobCount);
}
}
}
public void TestMultipleAsyncProcessors()
{
const int count = 300000;
AsyncProcessor lockProcessor1 = new AsyncProcessor(false);
AsyncProcessor lockProcessor2 = new AsyncProcessor(false);
AsyncProcessor lockProcessor3 = new AsyncProcessor(false);
AsyncProcessor lockProcessor4 = new AsyncProcessor(false);
ArrayList lockJobs = new ArrayList(count);
for (int i = 0; i < count; ++i)
{
lockJobs.Add(new LockJob());
}
for (int i = 0; i < count; ++i)
{
lockProcessor1.QueueJob((AbstractJob)lockJobs[i]);
lockProcessor2.QueueJob((AbstractJob)lockJobs[i]);
lockProcessor3.QueueJob((AbstractJob)lockJobs[i]);
lockProcessor4.QueueJob((AbstractJob)lockJobs[i]);
}
lockProcessor1.QueueEndOfWork();
lockProcessor2.QueueEndOfWork();
lockProcessor3.QueueEndOfWork();
lockProcessor4.QueueEndOfWork();
lockProcessor1.StartThread();
lockProcessor2.StartThread();
lockProcessor3.StartThread();
lockProcessor4.StartThread();
lockProcessor1.WaitUntilFinished();
lockProcessor2.WaitUntilFinished();
lockProcessor3.WaitUntilFinished();
lockProcessor4.WaitUntilFinished();
}
public void TestUnconditionalFinishOnDispose()
{
_jobCount = 0;
AsyncProcessor processor = new AsyncProcessor();
processor.QueueJob(new SleepJob(500));
processor.QueueJob(new ExceptionRaiser());
using ( processor )
{
Thread.Sleep(200);
}
// only sleep job should be executed, otherwise an exception will be raised
if (_jobCount != 1)
{
throw new Exception("UnconditionalFinishOnDispose() failed. _jobCount = " + _jobCount);
}
}
public void TestEmployCurrentThread()
{
_jobCount = 0;
AsyncProcessor proc = new AsyncProcessor(false);
using ( proc )
{
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new SleepJob(0));
proc.QueueJob(new SleepJob(0));
proc.QueueEndOfWork();
proc.EmployCurrentThread();
}
if (_jobCount != 3)
{
throw new Exception("TestEmployCurrentThread() failed. _jobCount = " + _jobCount);
}
}
public void TestMergingReenteringJobs()
{
_jobCount = 0;
AsyncProcessor processor = new AsyncProcessor();
using ( processor )
{
const int total = 5;
EnumeratorJob job = new EnumeratorJob(total, 100);
processor.QueueJob(job);
Thread.Sleep(250);
processor.QueueJob(job);
Thread.Sleep(550);
if (_jobCount != total + 2)
{
throw new Exception("TestMergingReenteringJobs() failed. _jobCount = " + _jobCount);
}
}
}
private void sleepOn10Sec(object sender, System.EventArgs e)
{
foreach (ListViewItem item in _listView.SelectedItems)
{
AsyncProcessor proc = item.Tag as AsyncProcessor;
if (proc != null)
{
proc.QueueJob("10 seconds sleeping", new MethodInvoker(Sleep10Seconds));
}
}
}
private void menuItem1_Click(object sender, System.EventArgs e)
{
foreach (ListViewItem item in _listView.SelectedItems)
{
AsyncProcessor proc = item.Tag as AsyncProcessor;
if (proc != null)
{
proc.QueueJob("Throw Exception", new MethodInvoker(ExceptionJob));
}
}
}
public void TestNamedJob()
{
AsyncProcessor proc = new AsyncProcessor();
using ( proc )
{
proc.QueueJob(new NamedJob());
Thread.Sleep(100);
if (proc.CurrentJobName != new NamedJob().Name)
{
throw new Exception("TestNamedJob() failed.");
}
}
}
public void TestReenteringGroup()
{
_jobCount = 0;
AsyncProcessor processor = new AsyncProcessor();
using ( processor )
{
const int total = 10;
processor.QueueJob(new GroupJob(total, 1));
Thread.Sleep(200);
if (_jobCount != total + 3)
{
throw new Exception("GroupJob( 10, 1 ) failed. _jobCount = " + _jobCount);
}
_jobCount = 0;
processor.QueueJob(new GroupJob(total, 5));
Thread.Sleep(200);
if (_jobCount != total + 3)
{
throw new Exception("GroupJob( 10, 5 ) failed. _jobCount = " + _jobCount);
}
_jobCount = 0;
processor.QueueJob(new GroupJob(total, 10));
Thread.Sleep(200);
if (_jobCount != total + 3)
{
throw new Exception("GroupJob( 10, 10 ) failed. _jobCount = " + _jobCount);
}
_jobCount = 0;
processor.QueueJob(new GroupJob(total, 15));
Thread.Sleep(200);
if (_jobCount != total + 3)
{
throw new Exception("GroupJob( 10, 15 ) failed. _jobCount = " + _jobCount);
}
}
}
public void MultiThreadedStress()
{
AsyncProcessor processor1 = new AsyncProcessor();
AsyncProcessor processor2 = new AsyncProcessor();
IBTree bTree1 = new /*BTree*/OmniaMeaBTree( _indexFileName, new TestKey( 0 ) );
IBTree bTree2 = new /*BTree*/OmniaMeaBTree( _indexFileName + "2", new TestKey( 0 ) );
processor1.QueueJob( new DoStressProcessingDelegate( DoStressProcessing ), bTree1 );
processor2.QueueJob( new DoStressProcessingDelegate( DoStressProcessing ), bTree2 );
using( processor1 )
{
using( processor2 )
{
Thread.Sleep( 1000 );
}
}
}
public void TestReenteringEnumerator()
{
_jobCount = 0;
AsyncProcessor processor = new AsyncProcessor();
using ( processor )
{
const int cycles = 10;
processor.QueueJob(new EnumeratorJob(cycles));
Thread.Sleep(200);
if (_jobCount != cycles + 1)
{
throw new Exception("TestReenteringEnumerator() failed. _jobCount = " + _jobCount);
}
}
}
public void TestExceptionDelegate()
{
AsyncProcessor processor = new AsyncProcessor();
_exceptionHandled = false;
using ( processor )
{
processor.ExceptionHandler = new AsyncExceptionHandler(ExceptionHandler);
processor.QueueJob(new ExceptionRaiser());
Thread.Sleep(200);
}
if (!_exceptionHandled)
{
throw new Exception("TestExceptionDelegate(): Async exception handling is not working.");
}
}
public void TestMultipleStepJob()
{
MultipleStepJob job = new MultipleStepJob();
AsyncProcessor processor = new AsyncProcessor();
using ( processor )
{
processor.QueueJob(job);
Thread.Sleep(200);
}
if (job.counter != 5)
{
throw new Exception("TestMultipleStepJob(): Invalid multiple step async processing. " + job.counter);
}
}
public void TestInvalidHandle()
{
_exceptionHandled = false;
AsyncProcessor proc = new AsyncProcessor();
using ( proc )
{
proc.ExceptionHandler = new AsyncExceptionHandler(ExceptionHandler);
proc.ProcessMessages = true;
proc.QueueJob(new InvalidHandleJob());
Thread.Sleep(500);
}
if (_exceptionHandled)
{
throw new Exception("There was an invalid handle exception!");
}
}
public void TestRunJobDuringFinishingAsyncProcessor()
{
_jobCount = 0;
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
using ( proc2 )
{
using ( proc1 )
{
proc2.QueueJob(JobPriority.Immediate, new SleepJob(200));
Thread.Sleep(50);
proc1.QueueJob(new RunJobInProcessor(proc2, new SleepJob(200)));
}
}
// test just will not hang-up
}
public void TestCrossRunJobsWithFinalSingleBlockingRun()
{
_jobCount = 0;
CrossRunJob._maxJobs = AsyncProcessor._maxWaitableHandles * 2 - 1;
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
CrossRunJob job = new CrossRunJob(proc1, proc2);
using ( proc1 )
{
using ( proc2 )
{
proc2.QueueJob(job);
Thread.Sleep(1000);
}
}
}
public void TestNamedRunJob()
{
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
using ( proc1 )
{
using ( proc2 )
{
proc1.QueueJob(new RunNamedJob(proc2));
Thread.Sleep(100);
if (proc2.CurrentJobName != new NamedJob().Name)
{
throw new Exception("TestNamedRunJob() failed.");
}
}
}
}
public void TestRunUniqieJobs()
{
SleepJob job = new SleepJob(200);
AsyncProcessor proc = new AsyncProcessor();
AsyncProcessor proc1 = new AsyncProcessor();
using ( proc )
{
using ( proc1 )
{
proc.QueueJob(JobPriority.Immediate, job);
Thread.Sleep(50);
proc1.QueueJob(new JobRunner(job, proc));
Thread.Sleep(50);
proc.RunUniqueJob(job); // this shouldn't throw an exception
}
}
}
public void TestSleep()
{
AsyncProcessor processor = new AsyncProcessor();
int start = Environment.TickCount;
// wait for two seconds in the thread of processor
using ( processor )
{
processor.QueueJob(new SleepJob(2000));
Thread.Sleep(200);
}
if (Environment.TickCount - start < 2000)
{
Console.WriteLine("Environment.TickCount=" + Environment.TickCount + " start=" + start);
throw new Exception("TestSleep(): sleep work finished earlier than it should.");
}
}
public void TestSimultaneousRunJobAndDispose()
{
_jobCount = 0;
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
using ( proc2 )
{
using ( proc1 )
{
for (int i = 0; i < 20; ++i)
{
proc1.QueueJob(JobPriority.Immediate, new SleepJob(20));
}
Thread.Sleep(50);
proc2.QueueJob(new RunJobInProcessor(proc1, new SleepJob(100)));
}
}
// test just will not hang-up
}
public void TestNonBlockingRun()
{
_jobCount = 0;
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
using ( proc1 )
{
using ( proc2 )
{
proc1.QueueJob(JobPriority.Immediate, new NonBlockingRunJob(proc2));
proc1.RunJob(new SleepJob(0));
Thread.Sleep(100);
if (_jobCount != 2)
{
throw new Exception("TestNonBlockingRun() failed. _jobCount = " + _jobCount);
}
}
}
}
public void TestAbortAsyncProThread()
{
AsyncProcessor processor = new AsyncProcessor();
_jobCount = 0;
using ( processor )
{
processor.QueueJobAt(DateTime.Now.AddSeconds(-1), new TimedJob());
processor.QueueJobAt(DateTime.Now.AddSeconds(2), new TimedJob());
Thread.Sleep(500);
processor.Thread.Abort();
// after thread was aborted async processor should restart its own thread
// and remain able to process units of work
processor.QueueJob(new TimedJob());
Thread.Sleep(2000);
}
if (_jobCount != 3)
{
throw new Exception("TestAbortAsyncProThread() failed. _jobCount = " + _jobCount);
}
}
public void TestRunWithException()
{
_exceptionHandled = false;
AsyncProcessor proc = new AsyncProcessor();
using ( proc )
{
proc.ExceptionHandler = new AsyncExceptionHandler(ExceptionHandler);
proc.QueueJob(new SleepJob(200));
AsyncProcessor proc1 = new AsyncProcessor();
AsyncProcessor proc2 = new AsyncProcessor();
AsyncProcessor proc3 = new AsyncProcessor();
AsyncProcessor proc4 = new AsyncProcessor();
AsyncProcessor proc5 = new AsyncProcessor();
proc1.QueueJob(new ExceptionJobRunner(proc));
proc2.QueueJob(new ExceptionJobRunner(proc));
proc3.QueueJob(new ExceptionJobRunner(proc));
proc4.QueueJob(new ExceptionJobRunner(proc));
proc5.QueueJob(new ExceptionJobRunner(proc));
try
{
proc.RunUniqueJob(new ExceptionJob());
}
catch (Exception e)
{
e = Utils.GetMostInnerException(e);
if (!(e is StrangeJobException))
{
throw new Exception(e.Message);
}
}
proc1.Dispose();
proc2.Dispose();
proc3.Dispose();
proc4.Dispose();
proc5.Dispose();
}
}
public void TestRunUniqueJobReturns()
{
count1 = count = 0;
using (AsyncProcessor proc = new AsyncProcessor())
{
using (AsyncProcessor proc1 = new AsyncProcessor())
{
for (int i = 0; i < 20; ++i)
{
bool queued = proc.QueueJob(new GetDelayedIntDelegate(GetDelayedInt), proc1, i);
if (!queued)
{
throw new Exception("QueueJob() didn't actually queue the job");
}
}
Thread.Sleep(1100);
}
}
if (count != 20 || count1 != 2)
{
throw new Exception("RunUniqueJob() wasn't executed specified number of times, count = " +
count + ", count1 = " + count1);
}
}
public void TestSpinWaitLock()
{
SpinWaitLock aLock = new SpinWaitLock();
AsyncProcessor proc1 = new AsyncProcessor(false);
AsyncProcessor proc2 = new AsyncProcessor(false);
using ( proc1 )
{
using ( proc2 )
{
for (int i = 0; i < 100000; ++i)
{
proc1.QueueJob(new SpinWaitLockJob(aLock));
proc2.QueueJob(new SpinWaitLockJob(aLock));
}
proc1.StartThread();
proc2.StartThread();
proc1.QueueEndOfWork();
proc2.QueueEndOfWork();
proc1.WaitUntilFinished();
proc2.WaitUntilFinished();
}
}
}
