public void EventPumpQueueLength(int numberOfProducers, bool producerDelay)
{
EventQueue q = new EventQueue();
EventProducer[] producers = new EventProducer[numberOfProducers];
for (int i = 0; i < numberOfProducers; i++)
{
producers[i] = new EventProducer(q, i, producerDelay);
}
using (EventPump pump = new EventPump(NullListener.NULL, q, false))
{
pump.Name = "EventPumpQueueLength";
pump.Start();
foreach (EventProducer p in producers)
{
p.ProducerThread.Start();
}
foreach (EventProducer p in producers)
{
p.ProducerThread.Join();
}
pump.Stop();
}
Assert.That(q.Count, Is.EqualTo(0));
foreach (EventProducer p in producers)
{
Console.WriteLine(
"#Events: {0}, MaxQueueLength: {1}", p.SentEventsCount, p.MaxQueueLength);
Assert.IsNull(p.Exception, "{0}", p.Exception);
}
}
private static void WaitForPumpToStop(EventPump pump, int waitTime)
{
while (waitTime > 0 && pump.PumpState != EventPumpState.Stopped)
{
Thread.Sleep(100);
waitTime -= 100;
}
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
EventPump pump = new EventPump( NullListener.NULL, q, true );
Assert.IsFalse( pump.Pumping, "Should not be pumping initially" );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump failed to start" );
q.Enqueue( new RunFinishedEvent( new Exception() ) );
WaitForPumpToStop( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
public void PumpEvents()
{
EventQueue q = new EventQueue();
EnqueueEvents( q );
QueuingEventListener el = new QueuingEventListener();
EventPump pump = new EventPump( el, q, false );
Assert.IsFalse( pump.Pumping, "Should not be pumping initially" );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump should still be running" );
StopPump( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump should have stopped" );
VerifyQueue( el.Events );
}
public void PumpEventsWithAutoStop()
{
EventQueue q = new EventQueue();
EnqueueEvents( q );
QueuingEventListener el = new QueuingEventListener();
EventPump pump = new EventPump( el, q, true );
pump.Start();
int tries = 10;
while( --tries > 0 && q.Count > 0 )
{
Thread.Sleep(100);
}
VerifyQueue( el.Events );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
public void TracingEventListenerDoesNotDeadlock()
{
QueuingEventListener upstreamListener = new QueuingEventListener();
EventQueue upstreamListenerQueue = upstreamListener.Events;
// Install a TraceListener sending TestOutput events to the upstreamListener.
// This simulates RemoteTestRunner.StartTextCapture, where TestContext installs such a TraceListener.
TextWriter traceWriter = new EventListenerTextWriter(upstreamListener, TestOutputType.Trace);
const string TraceListenerName = "TracingEventListenerDoesNotDeadlock";
TraceListener feedingTraceToUpstreamListener = new TextWriterTraceListener(traceWriter, TraceListenerName);
try
{
Trace.Listeners.Add(feedingTraceToUpstreamListener);
// downstreamListenerToTrace simulates an EventListener installed e.g. by an Addin,
// which may call Trace within the EventListener methods:
TracingEventListener downstreamListenerToTrace = new TracingEventListener();
using (EventPump pump = new EventPump(downstreamListenerToTrace, upstreamListenerQueue, false))
{
pump.Name = "TracingEventListenerDoesNotDeadlock";
pump.Start();
const int Repetitions = 10;
for (int i = 0; i < Repetitions; i++)
{
foreach (Event e in events)
{
Trace.WriteLine("Before sending {0} event.", e.GetType().Name);
e.Send(upstreamListener);
Trace.WriteLine("After sending {0} event.", e.GetType().Name);
}
}
}
}
finally
{
Trace.Listeners.Remove(TraceListenerName);
feedingTraceToUpstreamListener.Dispose();
}
}
public void PumpSynchronousAndAsynchronousEvents()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(NullListener.NULL, q, false))
{
pump.Name = "PumpSynchronousAndAsynchronousEvents";
pump.Start();
int numberOfAsynchronousEvents = 0;
int sumOfAsynchronousQueueLength = 0;
const int Repetitions = 2;
for (int i = 0; i < Repetitions; i++)
{
foreach (Event e in events)
{
q.Enqueue(e);
if (e.IsSynchronous)
{
Assert.That(q.Count, Is.EqualTo(0));
}
else
{
sumOfAsynchronousQueueLength += q.Count;
numberOfAsynchronousEvents++;
}
}
}
Console.WriteLine("Average queue length: {0}", (float)sumOfAsynchronousQueueLength / numberOfAsynchronousEvents);
}
}
public void PumpPendingEventsAfterAutoStop()
{
EventQueue q = new EventQueue();
EnqueueEvents(q);
Event[] eventsAfterStop =
{
new OutputEvent(new TestOutput("foo", TestOutputType.Out)),
new OutputEvent(new TestOutput("bar", TestOutputType.Trace)),
};
foreach (Event e in eventsAfterStop)
{
q.Enqueue(e);
}
QueuingEventListener el = new QueuingEventListener();
using (EventPump pump = new EventPump(el, q, true))
{
pump.Name = "PumpPendingEventsAfterAutoStop";
pump.Start();
int tries = 10;
while (--tries > 0 && q.Count > 0)
{
Thread.Sleep(100);
}
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
Assert.That(el.Events.Count, Is.EqualTo(events.Length + eventsAfterStop.Length));
}
public void PumpEventsWithAutoStop()
{
EventQueue q = new EventQueue();
QueuingEventListener el = new QueuingEventListener();
using (EventPump pump = new EventPump(el, q, true))
{
pump.Name = "PumpEventsWithAutoStop";
pump.Start();
EnqueueEvents(q);
int tries = 10;
while (--tries > 0 && q.Count > 0)
{
Thread.Sleep(100);
}
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
}
public void PumpEvents()
{
EventQueue q = new EventQueue();
QueuingEventListener el = new QueuingEventListener();
using (EventPump pump = new EventPump(el, q, false))
{
pump.Name = "PumpEvents";
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
EnqueueEvents(q);
StopPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
VerifyQueue(el.Events);
}
public void PumpAutoStopsOnRunFinished()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(NullListener.NULL, q, true))
{
pump.Name = "PumpAutoStopsOnRunFinished";
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
q.Enqueue(new RunFinishedEvent(new Exception()));
WaitForPumpToStop(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
}
private void WaitForPumpToStop( EventPump pump, int waitTime )
{
while( waitTime > 0 && pump.Pumping )
{
Thread.Sleep( 10 );
waitTime -= 10;
}
}
private void StartPump( EventPump pump, int waitTime )
{
pump.Start();
while( waitTime > 0 && !pump.Pumping )
{
Thread.Sleep( 10 );
waitTime -= 10;
}
}
public void StartAndStopPumpOnEmptyQueue()
{
EventPump pump = new EventPump( NullListener.NULL, new EventQueue(), false );
StartPump( pump, 1000 );
Assert.IsTrue( pump.Pumping, "Pump failed to start" );
StopPump( pump, 1000 );
Assert.IsFalse( pump.Pumping, "Pump failed to stop" );
}
private static void StopPump(EventPump pump, int waitTime)
{
pump.Stop();
WaitForPumpToStop(pump, waitTime);
}
public void StartAndStopPumpOnEmptyQueue()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(NullListener.NULL, q, false))
{
pump.Name = "StartAndStopPumpOnEmptyQueue";
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
StopPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
}
}
private static void StopPump(EventPump pump, int waitTime)
{
pump.Stop();
WaitForPumpToStop(pump, waitTime);
}
