private static void WaitForPumpToStart(EventPump pump, int waitTime)
{
while (waitTime > 0 && pump.PumpState != EventPumpState.Pumping)
{
Thread.Sleep(100);
waitTime -= 100;
}
}
private static void StopPump(EventPump pump, int waitTime)
{
pump.Stop();
WaitForPumpToStop(pump, waitTime);
}
public void PumpEvents()
{
EventQueue q = new EventQueue();
QueuingEventListener el = new QueuingEventListener();
using (EventPump pump = new EventPump(el, q))
{
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 PumpSynchronousAndAsynchronousEvents()
{
EventQueue q = new EventQueue();
using (EventPump pump = new EventPump(TestListener.NULL, q))
{
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);
sumOfAsynchronousQueueLength += q.Count;
numberOfAsynchronousEvents++;
}
}
Console.WriteLine("Average queue length: {0}", (float)sumOfAsynchronousQueueLength / numberOfAsynchronousEvents);
}
}
/// <summary>
/// Run selected tests and return a test result. The test is run synchronously,
/// and the listener interface is notified as it progresses.
/// </summary>
/// <param name="listener">Interface to receive EventListener notifications.</param>
/// <param name="filter">A test filter used to select tests to be run</param>
/// <returns></returns>
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
log.Info("Running tests");
if (_loadedTest == null)
throw new InvalidOperationException("Run was called but no test has been loaded.");
// Save Console.Out and Error for later restoration
TextWriter savedOut = Console.Out;
TextWriter savedErr = Console.Error;
TestExecutionContext initialContext = CreateTestExecutionContext(_settings);
#if NUNITLITE
initialContext.Listener = listener;
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
workItem.Execute();
_runComplete.WaitOne();
return workItem.Result;
#else
QueuingEventListener queue = new QueuingEventListener();
if (_settings.Contains("CaptureStandardOutput"))
initialContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
if (_settings.Contains("CapureStandardError"))
initialContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
initialContext.Listener = queue;
int numWorkers = _settings.Contains("NumberOfTestWorkers")
? (int)_settings["NumberOfTestWorkers"]
: 0;
WorkItemDispatcher dispatcher = null;
if (numWorkers > 0)
{
dispatcher = new WorkItemDispatcher(numWorkers);
initialContext.Dispatcher = dispatcher;
}
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
using (EventPump pump = new EventPump(listener, queue.Events))
{
pump.Start();
if (dispatcher != null)
{
dispatcher.Dispatch(workItem);
dispatcher.Start();
}
else
workItem.Execute();
_runComplete.WaitOne();
}
Console.SetOut(savedOut);
Console.SetError(savedErr);
if (dispatcher != null)
{
dispatcher.Stop();
dispatcher = null;
}
return workItem.Result;
#endif
}
public void StartAndStopPumpOnEmptyQueue()
{
using (EventPump pump = new EventPump(TestListener.NULL, new EventQueue()))
{
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));
}
}
/// <summary>
/// Initiate the test run.
/// </summary>
public void StartRun(ITestListener listener)
{
#if !SILVERLIGHT && !NETCF && !PORTABLE
// Save Console.Out and Error for later restoration
_savedOut = Console.Out;
_savedErr = Console.Error;
Console.SetOut(new TextCapture(Console.Out));
Console.SetError(new TextCapture(Console.Error));
#endif
#if PARALLEL
// Queue and pump events, unless settings have SynchronousEvents == false
if (!Settings.Contains(PackageSettings.SynchronousEvents) || !(bool)Settings[PackageSettings.SynchronousEvents])
{
QueuingEventListener queue = new QueuingEventListener();
Context.Listener = queue;
_pump = new EventPump(listener, queue.Events);
_pump.Start();
}
#endif
if (!System.Diagnostics.Debugger.IsAttached &&
Settings.Contains(PackageSettings.DebugTests) &&
(bool)Settings[PackageSettings.DebugTests])
{
System.Diagnostics.Debugger.Launch();
}
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
/// <summary>
/// Initiate the test run.
/// </summary>
public void StartRun(ITestListener listener)
{
#if !SILVERLIGHT && !NETCF && !PORTABLE
// Save Console.Out and Error for later restoration
_savedOut = Console.Out;
_savedErr = Console.Error;
Console.SetOut(new TextCapture(Console.Out));
Console.SetError(new TextCapture(Console.Error));
#endif
#if PARALLEL
QueuingEventListener queue = new QueuingEventListener();
Context.Listener = queue;
_pump = new EventPump(listener, queue.Events);
_pump.Start();
#else
Context.Dispatcher = new SimpleWorkItemDispatcher();
#endif
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
/// <summary>
/// Initiate the test run.
/// </summary>
public override void StartRun(ITestListener listener)
{
// Save Console.Out and Error for later restoration
_savedOut = Console.Out;
_savedErr = Console.Error;
Console.SetOut(new TextCapture(Console.Out));
Console.SetError(new TextCapture(Console.Error));
QueuingEventListener queue = new QueuingEventListener();
Context.Listener = queue;
_pump = new EventPump(listener, queue.Events);
_pump.Start();
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
/// <summary>
/// Initiate the test run.
/// </summary>
public override void StartRun(ITestListener listener)
{
// Save Console.Out and Error for later restoration
_savedOut = Console.Out;
_savedErr = Console.Error;
QueuingEventListener queue = new QueuingEventListener();
if (Settings.Contains(DriverSettings.CaptureStandardOutput))
Context.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
if (Settings.Contains(DriverSettings.CaptureStandardError))
Context.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
Context.Listener = queue;
using (EventPump pump = new EventPump(listener, queue.Events))
{
pump.Start();
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
}
private static void StartPump(EventPump pump, int waitTime)
{
pump.Start();
WaitForPumpToStart(pump, waitTime);
}
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(TestListener.NULL, q))
{
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);
}
}
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))
{
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();
}
}
/// <summary>
/// Run selected tests and return a test result. The test is run synchronously,
/// and the listener interface is notified as it progresses.
/// </summary>
/// <param name="listener">Interface to receive EventListener notifications.</param>
/// <param name="filter">A test filter used to select tests to be run</param>
/// <returns></returns>
public ITestResult Run(ITestListener listener, ITestFilter filter)
{
log.Info("Running tests");
if (_loadedTest == null)
throw new InvalidOperationException("The Run method was called but no test has been loaded");
// Save Console.Out and Error for later restoration
TextWriter savedOut = Console.Out;
TextWriter savedErr = Console.Error;
TestExecutionContext initialContext = CreateTestExecutionContext(_settings);
#if NUNITLITE
initialContext.Listener = listener;
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
workItem.Execute();
_runComplete.WaitOne();
return workItem.Result;
#else
QueuingEventListener queue = new QueuingEventListener();
if (_settings.Contains(DriverSettings.CaptureStandardOutput))
initialContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
if (_settings.Contains(DriverSettings.CaptureStandardError))
initialContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
initialContext.Listener = queue;
int levelOfParallelization = _settings.Contains(DriverSettings.NumberOfTestWorkers)
? (int)_settings[DriverSettings.NumberOfTestWorkers]
: _loadedTest.Properties.ContainsKey(PropertyNames.LevelOfParallelization)
? (int)_loadedTest.Properties.Get(PropertyNames.LevelOfParallelization)
: Math.Max(Environment.ProcessorCount, 2);
WorkItemDispatcher dispatcher = null;
if (levelOfParallelization > 0)
{
dispatcher = new WorkItemDispatcher(levelOfParallelization);
initialContext.Dispatcher = dispatcher;
// Assembly does not have IApplyToContext attributes applied
// when the test is built, so we do it here.
// TODO: Generalize this
if (_loadedTest.Properties.ContainsKey(PropertyNames.ParallelScope))
initialContext.ParallelScope =
(ParallelScope)_loadedTest.Properties.Get(PropertyNames.ParallelScope) & ~ParallelScope.Self;
}
WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter);
workItem.Completed += new EventHandler(OnRunCompleted);
using (EventPump pump = new EventPump(listener, queue.Events))
{
pump.Start();
if (dispatcher != null)
{
dispatcher.Dispatch(workItem);
dispatcher.Start();
}
else
workItem.Execute();
_runComplete.WaitOne();
}
Console.SetOut(savedOut);
Console.SetError(savedErr);
if (dispatcher != null)
{
dispatcher.Stop();
dispatcher = null;
}
return workItem.Result;
#endif
}
/// <summary>
/// Initiate the test run.
/// </summary>
private void StartRun(ITestListener listener)
{
#if !PORTABLE
// Save Console.Out and Error for later restoration
_savedOut = Console.Out;
_savedErr = Console.Error;
Console.SetOut(new TextCapture(Console.Out));
Console.SetError(new EventListenerTextWriter("Error", Console.Error));
#endif
#if PARALLEL
// Queue and pump events, unless settings have SynchronousEvents == false
if (!Settings.ContainsKey(FrameworkPackageSettings.SynchronousEvents) || !(bool)Settings[FrameworkPackageSettings.SynchronousEvents])
{
QueuingEventListener queue = new QueuingEventListener();
Context.Listener = queue;
_pump = new EventPump(listener, queue.Events);
_pump.Start();
}
#endif
if (!System.Diagnostics.Debugger.IsAttached &&
Settings.ContainsKey(FrameworkPackageSettings.DebugTests) &&
(bool)Settings[FrameworkPackageSettings.DebugTests])
System.Diagnostics.Debugger.Launch();
#if !PORTABLE
if (Settings.ContainsKey(FrameworkPackageSettings.PauseBeforeRun) &&
(bool)Settings[FrameworkPackageSettings.PauseBeforeRun])
PauseBeforeRun();
#endif
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
