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 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 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; } }