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 StartStopEventPump( ) { ManualResetEventSlim signal = new ManualResetEventSlim(false); eventPump.EventPumpStateChanged += (arg) => { signal.Set(); }; Task task = Task.Factory.StartNew(() => eventPump.Start()); signal.Wait(); signal.Reset(); Assert.IsTrue(eventPump.IsRunning); // let it run Thread.Sleep(500); eventPump.Stop(); signal.Wait(); Assert.IsFalse(eventPump.IsRunning); signal.Dispose(); task.Dispose(); }
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); } }
/// <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)); }
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 void StartPump(EventPump pump, int waitTime) { pump.Start(); while (waitTime > 0 && !pump.Pumping) { Thread.Sleep(10); waitTime -= 10; } }
/// <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); }
private static void CreateCoreDLNativeWindow( ) { var window = new NativeWindow("CoreDL Native Window"); using (EventPump eventPump = EventPump.Instance) { eventPump.Start(window); /* * because EventPump was started with window, it will dispose * of window when it disposes * ***/ } }
/// <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" ); }
/// <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> /// 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 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 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)); } }
///// <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 }
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)); }
private static void StartPump(EventPump pump, int waitTime) { pump.Start(); WaitForPumpToStart(pump, waitTime); }
private static void StartPump(EventPump pump, int waitTime) { pump.Start(); WaitForPumpToStart(pump, waitTime); }
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); } }
/// <summary> /// Windowless /// </summary> public virtual void Run( ) { eventPump.Start(); }
private void StartPump( EventPump pump, int waitTime ) { pump.Start(); while( waitTime > 0 && !pump.Pumping ) { Thread.Sleep( 10 ); waitTime -= 10; } }