public void SendEvents()
{
QueuingEventListener el = new QueuingEventListener();
SendEvents(el);
VerifyQueue(el.Events);
}
/// <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
if (!System.Diagnostics.Debugger.IsAttached &&
Settings.Contains(PackageSettings.DebugTests) &&
(bool)Settings[PackageSettings.DebugTests])
{
System.Diagnostics.Debugger.Launch();
}
Context.Dispatcher.Dispatch(TopLevelWorkItem);
}
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));
}
/// <summary>
/// Initiate the test run.
/// </summary>
private 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 EventListenerTextWriter("Error", Console.Error));
#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])
{
try
{
System.Diagnostics.Debugger.Launch();
}
#if !NETSTANDARD1_6
catch (SecurityException)
{
TopLevelWorkItem.MarkNotRunnable("System.Security.Permissions.UIPermission is not set to start the debugger.");
return;
}
#endif
//System.Diagnostics.Debugger.Launch() not implemented on mono
catch (NotImplementedException)
{
TopLevelWorkItem.MarkNotRunnable("Debugger unavailable on this platform.");
return;
}
}
#if NET20 || NET35 || NET40 || NET45
if (Settings.ContainsKey(FrameworkPackageSettings.PauseBeforeRun) &&
(bool)Settings[FrameworkPackageSettings.PauseBeforeRun])
{
PauseBeforeRun();
}
#endif
Context.Dispatcher.Start(TopLevelWorkItem);
}
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 );
}
/// <summary>
/// Initiate the test run.
/// </summary>
private 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 EventListenerTextWriter("Error", Console.Error));
// 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();
}
if (!System.Diagnostics.Debugger.IsAttached &&
Settings.ContainsKey(FrameworkPackageSettings.DebugTests) &&
(bool)Settings[FrameworkPackageSettings.DebugTests])
{
try
{
System.Diagnostics.Debugger.Launch();
}
catch (SecurityException)
{
TopLevelWorkItem.MarkNotRunnable("System.Security.Permissions.UIPermission must be granted in order to launch the debugger.");
return;
}
//System.Diagnostics.Debugger.Launch() not implemented on mono
catch (NotImplementedException)
{
TopLevelWorkItem.MarkNotRunnable("This platform does not support launching the debugger.");
return;
}
}
#if NETFRAMEWORK
if (Settings.ContainsKey(FrameworkPackageSettings.PauseBeforeRun) &&
(bool)Settings[FrameworkPackageSettings.PauseBeforeRun])
{
PauseBeforeRun();
}
#endif
Context.Dispatcher.Start(TopLevelWorkItem);
}
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 PumpEvents()
{
EventQueue q = new EventQueue();
EnqueueEvents(q);
QueuingEventListener el = new QueuingEventListener();
EventPump pump = new EventPump(el, q, false);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
StartPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Pumping));
StopPump(pump, 1000);
Assert.That(pump.PumpState, Is.EqualTo(EventPumpState.Stopped));
VerifyQueue(el.Events);
}
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);
}
/// <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);
}
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 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 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();
}
}
/// <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 && !NETSTANDARD1_6
if (Settings.ContainsKey(FrameworkPackageSettings.PauseBeforeRun) &&
(bool)Settings[FrameworkPackageSettings.PauseBeforeRun])
{
PauseBeforeRun();
}
#endif
Context.Dispatcher.Start(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>
///// Count Test Cases using a filter
///// </summary>
///// <param name="filter">The filter to apply</param>
///// <returns>The number of test cases found</returns>
//public int CountTestCases(TestFilter filter)
//{
// return this.suite.CountTestCases(filter);
//}
/// <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
}
/// <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 levelOfParallelization = _settings.Contains("NumberOfTestWorkers")
? (int)_settings["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
}
public void SendEvents()
{
QueuingEventListener el = new QueuingEventListener();
SendEvents(el);
VerifyQueue(el.Events);
}
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 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 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 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));
}
