private void FlushQueuedLogs()
{
bool scroll = false;
bool open = false;
while (!_queuedLogs.IsEmpty)
{
if (_queuedLogs.TryDequeue(out Log log))
{
AppendLogTrace(log.LogText);
LoggingThreshold severity = log.LogType.ToLoggingThreshold();
scroll |= _autoScroll == AutoScrollOptions.Always;
open |= severity <= _openOnLogLevel;
}
}
if (scroll)
{
ScrollConsoleToLatest();
}
if (open)
{
Activate(false);
}
}
public void StartRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
this.listener = listener;
this.filter = filter;
this.tracing = tracing;
this.logLevel = logLevel;
thread.Start();
}
/// <summary>
/// Run selected tests using a filter
/// </summary>
/// <param name="filter">The filter to be used</param>
public void RunTests(ITestFilter filter)
{
if (!Running && LoadedTest != null)
{
if (reloadPending || Services.UserSettings.GetSetting("Options.TestLoader.ReloadOnRun", false))
{
ReloadTest();
}
// Save args for automatic rerun
this.lastFilter = filter;
this.lastTracing = tracing;
this.lastLogLevel = logLevel;
testRunner.BeginRun(this, filter, tracing, logLevel);
}
}
private void StartTextCapture(EventListener queue, bool tracing, LoggingThreshold logLevel)
{
TestExecutionContext.CurrentContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
TestExecutionContext.CurrentContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
TestExecutionContext.CurrentContext.Tracing = false;
if (tracing)
{
TestExecutionContext.CurrentContext.TraceWriter = new EventListenerTextWriter(queue, TestOutputType.Trace);
TestExecutionContext.CurrentContext.Tracing = true;
}
TestExecutionContext.CurrentContext.LogLevel = LoggingThreshold.Off;
if (logLevel != LoggingThreshold.Off)
{
TestExecutionContext.CurrentContext.LogWriter = new EventListenerTextWriter(queue, TestOutputType.Log);
TestExecutionContext.CurrentContext.LogLevel = logLevel;
}
}
public static LoggingThreshold ToLoggingThreshold(this LogType logType)
{
LoggingThreshold severity = LoggingThreshold.Always;
switch (logType)
{
case LogType.Exception: severity = LoggingThreshold.Exception; break;
case LogType.Error: severity = LoggingThreshold.Error; break;
case LogType.Assert: severity = LoggingThreshold.Error; break;
case LogType.Warning: severity = LoggingThreshold.Warning; break;
case LogType.Log: severity = LoggingThreshold.Always; break;
}
return(severity);
}
public virtual void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
// Save active listener for derived classes
this.listener = listener;
Log.Info("BeginRun");
// ThreadedTestRunner will call our Run method on a separate thread
ThreadedTestRunner threadedRunner = new ThreadedTestRunner(this);
threadedRunner.BeginRun(listener, filter, tracing, logLevel);
}
public override void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Info("BeginRun");
testRunnerThread = new TestRunnerThread(this.TestRunner, this.apartmentState, this.priority);
testRunnerThread.StartRun(listener, filter, tracing, logLevel);
}
/// <summary>
/// Run selected tests using a filter
/// </summary>
/// <param name="filter">The filter to be used</param>
public void RunTests( ITestFilter filter )
{
if ( !Running && LoadedTest != null)
{
if (reloadPending || Services.UserSettings.GetSetting("Options.TestLoader.ReloadOnRun", false))
ReloadTest();
// Save args for automatic rerun
this.lastFilter = filter;
this.lastTracing = tracing;
this.lastLogLevel = logLevel;
testRunner.BeginRun(this, filter, tracing, logLevel);
}
}
public override TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Debug("Run");
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture(queue, tracing, logLevel);
using (EventPump pump = new EventPump(listener, queue.Events, true))
{
pump.Start();
return(base.Run(queue, filter, tracing, logLevel));
}
}
public override void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Info("BeginRun in AppDomain {0}", domain.FriendlyName);
base.BeginRun(listener, filter, tracing, logLevel);
}
public virtual void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
// Save active listener for derived classes
this.listener = listener;
this.testRunner.BeginRun(listener, filter, tracing, logLevel);
}
public virtual TestResult Run( EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel )
{
try
{
log.Debug("Starting test run");
// Take note of the fact that we are running
this.runThread = Thread.CurrentThread;
listener.RunStarted( this.Test.TestName.FullName, test.CountTestCases( filter ) );
testResult = test.Run( listener, filter );
// Signal that we are done
listener.RunFinished( testResult );
log.Debug("Test run complete");
// Return result array
return testResult;
}
catch( Exception exception )
{
// Signal that we finished with an exception
listener.RunFinished( exception );
// Rethrow - should we do this?
throw;
}
finally
{
runThread = null;
}
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
Log.Info("Run - EventListener={0}", listener.GetType().Name);
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for (int index = 0; index < runners.Count; index++)
{
tests[index] = ((TestRunner)runners[index]).Test;
}
string name = this.testName.Name;
int count = this.CountTestCases(filter);
Log.Info("Signalling RunStarted({0},{1})", name, count);
this.listener.RunStarted(name, count);
#if CLR_2_0 || CLR_4_0
long startTime = Stopwatch.GetTimestamp();
#else
long startTime = DateTime.Now.Ticks;
#endif
TestResult result = new TestResult(new TestInfo(testName, tests));
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
runner.BeginRun(this, filter, tracing, logLevel);
}
}
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
{
if (filter.Pass(runner.Test))
{
result.AddResult(runner.Run(this, filter, tracing, logLevel));
}
}
}
#if CLR_2_0 || CLR_4_0
long stopTime = Stopwatch.GetTimestamp();
double time = ((double)(stopTime - startTime)) / (double)Stopwatch.Frequency;
#else
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
#endif
result.Time = time;
this.listener.RunFinished(result);
this.testResult = result;
return(result);
}
public void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
testResult = this.Run(listener, filter, tracing, logLevel);
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
try
{
log.Debug("Starting test run");
// Take note of the fact that we are running
this.runThread = Thread.CurrentThread;
if (_compatibility)
{
Compatibility.BeginCollection(_workDirectory);
TestExecutionContext.CurrentContext.CompatibilityWriter = Compatibility.Writer;
}
listener.RunStarted(this.Test.TestName.FullName, test.CountTestCases(filter));
testResult = test.Run(listener, filter);
// Signal that we are done
listener.RunFinished(testResult);
log.Debug("Test run complete");
// Return result array
return(testResult);
}
catch (Exception exception)
{
// Signal that we finished with an exception
listener.RunFinished(exception);
// Rethrow - should we do this?
throw;
}
finally
{
runThread = null;
if (_compatibility)
{
Compatibility.EndCollection();
}
}
}
public override TestResult Run( EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel )
{
log.Debug("Run");
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture( queue, tracing, logLevel );
using( EventPump pump = new EventPump( listener, queue.Events, true ) )
{
pump.Start();
return base.Run( queue, filter, tracing, logLevel );
}
}
private void StartTextCapture( EventListener queue, bool tracing, LoggingThreshold logLevel )
{
TestExecutionContext.CurrentContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out);
TestExecutionContext.CurrentContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error);
TestExecutionContext.CurrentContext.Tracing = false;
if (tracing)
{
TestExecutionContext.CurrentContext.TraceWriter = new EventListenerTextWriter(queue, TestOutputType.Trace);
TestExecutionContext.CurrentContext.Tracing = true;
}
TestExecutionContext.CurrentContext.LogLevel = LoggingThreshold.Off;
if (logLevel != LoggingThreshold.Off)
{
TestExecutionContext.CurrentContext.LogWriter = new EventListenerTextWriter(queue, TestOutputType.Log);
TestExecutionContext.CurrentContext.LogLevel = logLevel;
}
}
public override void BeginRun( EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel )
{
log.Debug("BeginRun");
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture( queue, tracing, logLevel );
EventPump pump = new EventPump( listener, queue.Events, true);
pump.Start(); // Will run till RunFinished is received
// TODO: Make sure the thread is cleaned up if we abort the run
base.BeginRun( queue, filter, tracing, logLevel );
}
public void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
testResult = this.Run(listener, filter, tracing, logLevel);
}
public override void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Info("BeginRun in AppDomain {0}", domain.FriendlyName);
base.BeginRun(listener, filter, tracing, logLevel);
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
// Save active listener for derived classes
this.listener = listener;
return(this.testRunner.Run(listener, filter, tracing, logLevel));
}
public override TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
BeginRun(listener, filter, tracing, logLevel);
return(EndRun());
}
public virtual void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
// Save active listener for derived classes
this.listener = listener;
this.testRunner.BeginRun(listener, filter, tracing, logLevel);
}
public override void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Info("BeginRun");
testRunnerThread = new TestRunnerThread(this.TestRunner, this.apartmentState, this.priority);
testRunnerThread.StartRun(listener, filter, tracing, logLevel);
}
public void StartRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
this.listener = listener;
this.filter = filter;
this.tracing = tracing;
this.logLevel = logLevel;
thread.Start();
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
Log.Info("Run - EventListener={0}", listener.GetType().Name);
// Save active listener for derived classes
this.listener = listener;
ITest[] tests = new ITest[runners.Count];
for( int index = 0; index < runners.Count; index++ )
tests[index] = ((TestRunner)runners[index]).Test;
string name = this.testName.Name;
int count = this.CountTestCases(filter);
Log.Info("Signalling RunStarted({0},{1})", name, count);
this.listener.RunStarted(name, count);
long startTime = DateTime.Now.Ticks;
TestResult result = new TestResult(new TestInfo(testName, tests));
if (this.runInParallel)
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
runner.BeginRun(this, filter, tracing, logLevel);
result = this.EndRun();
}
else
{
foreach (TestRunner runner in runners)
if (filter.Pass(runner.Test))
result.AddResult(runner.Run(this, filter, tracing, logLevel));
}
long stopTime = DateTime.Now.Ticks;
double time = ((double)(stopTime - startTime)) / (double)TimeSpan.TicksPerSecond;
result.Time = time;
this.listener.RunFinished( result );
this.testResult = result;
return result;
}
public override void BeginRun(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
log.Debug("BeginRun");
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture(queue, tracing, logLevel);
EventPump pump = new EventPump(listener, queue.Events, true);
pump.Start(); // Will run till RunFinished is received
// TODO: Make sure the thread is cleaned up if we abort the run
base.BeginRun(queue, filter, tracing, logLevel);
}
public virtual void BeginRun( EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel )
{
// Save active listener for derived classes
this.listener = listener;
Log.Info("BeginRun");
// ThreadedTestRunner will call our Run method on a separate thread
ThreadedTestRunner threadedRunner = new ThreadedTestRunner(this);
threadedRunner.BeginRun(listener, filter, tracing, logLevel);
}
public override TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
BeginRun(listener, filter, tracing, logLevel);
return EndRun();
}
public virtual TestResult Run(EventListener listener, ITestFilter filter, bool tracing, LoggingThreshold logLevel)
{
try
{
log.Debug("Starting test run");
// Take note of the fact that we are running
this.runThread = Thread.CurrentThread;
listener.RunStarted(this.Test.TestName.FullName, test.CountTestCases(filter));
testResult = test.Run(listener, filter);
// Signal that we are done
listener.RunFinished(testResult);
log.Debug("Test run complete");
// Return result array
return(testResult);
}
catch (Exception exception)
{
// Signal that we finished with an exception
listener.RunFinished(exception);
// Rethrow - should we do this?
throw;
}
finally
{
runThread = null;
}
}
