/// <summary> /// Initializes a new instance of the <see cref="TextUI"/> class. /// </summary> /// <param name="writer">The TextWriter to use.</param> /// <param name="listener">The Test listener to use.</param> public TextUI(TextWriter writer, ITestListener listener) { // Set the default writer - may be overridden by the args specified this.writer = writer; this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder()); this.listener = listener; }
public void AddListener (ITestListener listener) { lock (listeners.SyncRoot) { listeners.Add (listener); } }
public TdNetRunnerHelper(Assembly assembly, ITestListener testListener) { this.testListener = testListener; xunit = new Xunit2(new NullSourceInformationProvider(), assembly.GetLocalCodeBase()); toDispose.Push(xunit); }
TestRunState ITestRunner.RunNamespace(ITestListener testListener, Assembly assembly, string ns) { return TestRunState.NoTests; //TODO: Fix filter. ns is probably equal to NamespaceFilter in StoryRunnerFilter //return Run(assembly, null, testListener); }
public AdapterFacadeTestListener(ITestListener testListener) { if (testListener == null) throw new ArgumentNullException("testListener"); this.testListener = testListener; }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { var method = member as MethodInfo; if (method != null) { if (method.IsDispose()) { var listener = new TestDrivenListener(testListener); listener.CaseSkipped(new SkipResult(new Case(method), "Dispose() is not a test.")); return TestRunState.Success; } return Run(testListener, runner => runner.RunMethods(assembly, method)); } var type = member as Type; if (type != null) { var types = GetTypeAndNestedTypes(type).ToArray(); return Run(testListener, runner => runner.RunTypes(assembly, types)); } return TestRunState.Error; }
private bool ValidateParameters(ITestListener listener, DataRow dataRow) { if(_expectedParameterNum == dataRow.Values.Length) { var parameters = MethodInfo.GetParameters(); var paramValues = new object[parameters.Length]; for(var i = 0; i < parameters.Length; i++) { try { paramValues[i] = Convert.ChangeType(dataRow.Values[i], parameters[i].ParameterType); } catch(InvalidCastException) { ReportError(listener, string.Format( "Parameter types don't match for DataRow({0}).", dataRow)); return false; } catch(FormatException) { ReportError(listener, string.Format( "Parameter types don't match for DataRow({0}).", dataRow)); return false; } catch(Exception ex) { ReportError(listener, "Failed to convert parameter." + ex.Message); return false; } } dataRow.Values = paramValues; return true; } ReportError(listener, string.Format("Each data row for {0} must have {1} values.", MethodInfo.Name, _expectedParameterNum)); return false; }
TestRunState ITdNetTestRunner.RunMember(ITestListener listener, Assembly assembly, MemberInfo member) { try { using (ExecutorWrapper wrapper = new ExecutorWrapper(new Uri(assembly.CodeBase).LocalPath, null, false)) { TdNetLogger logger = new TdNetLogger(listener, assembly); TestRunner runner = new TestRunner(wrapper, logger); MethodInfo method = member as MethodInfo; if (method != null) return RunMethod(runner, method); Type type = member as Type; if (type != null) return RunClassWithInnerTypes(runner, type); return TestRunState.NoTests; } } catch (ArgumentException) { return TestRunState.NoTests; } }
public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns) { using (var helper = CreateHelper(testListener, assembly)) { var testCases = helper.Discover().Where(tc => ns == null || tc.GetClass().Namespace == ns); return helper.Run(testCases); } }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { var listener = new TDNetRunListener(testListener); var runner = new AppDomainRunner(listener, RunOptions.Default); runner.RunMember(assembly, member); return listener.TestRunState; }
public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns) { var listener = new TDNetRunListener(testListener); var runner = new AppDomainRunner(listener, RunOptions.Default); runner.RunNamespace(assembly, ns); return listener.TestRunState; }
public virtual void Run(ITestListener listener) { listener.RunStarted(); ITestExecutor executor = new _ITestExecutor_19(this, listener); Environments.RunWith(Environments.NewClosedEnvironment(new object[] {executor}) , new _IRunnable_28(this, listener)); listener.RunFinished(); }
public TdNetRunnerHelper(Assembly assembly, ITestListener testListener) { this.testListener = testListener; var assemblyFileName = assembly.GetLocalCodeBase(); configuration = ConfigReader.Load(assemblyFileName); var diagnosticMessageSink = new DiagnosticMessageSink(testListener, Path.GetFileNameWithoutExtension(assemblyFileName), configuration.DiagnosticMessagesOrDefault); xunit = new Xunit2(configuration.AppDomainOrDefault, new NullSourceInformationProvider(), assemblyFileName, shadowCopy: false, diagnosticMessageSink: diagnosticMessageSink); toDispose.Push(xunit); }
/// <summary> /// Initializes a new instance of the <see cref="TextUI"/> class. /// </summary> /// <param name="writer">The TextWriter to use.</param> /// <param name="listener">The Test listener to use.</param> public TextUI(TextWriter writer, ITestListener listener) { // Set the default writer - may be overridden by the args specified this.writer = writer; this.finallyDelegate = new FinallyDelegate(); this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder(), this.finallyDelegate); this.listener = listener; AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(this.TopLevelHandler); }
public TestRunState Run(ITestListener testListener, string assemblyFile, string cref) { if (testListener == null) throw new ArgumentNullException("testListener"); if (assemblyFile == null) throw new ArgumentNullException("assemblyFile"); FacadeOptions options = FacadeOptions.ReadFromRegistry(); FacadeTestRunState result = TestRunner.Run(new AdapterFacadeTestListener(testListener), assemblyFile, cref, options); return FacadeUtils.ToTestRunState(result); }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { var method = member as MethodInfo; if (method != null) return Run(testListener, runner => runner.RunMethod(assembly, method)); var type = member as Type; if (type != null) return Run(testListener, runner => runner.RunType(assembly, type)); return TestRunState.Error; }
public TestRunState RunAssembly(ITestListener testListener, Assembly assembly) { if (testListener == null) throw new ArgumentNullException("testListener"); if (assembly == null) throw new ArgumentNullException("assembly"); FacadeOptions options = FacadeOptions.ReadFromRegistry(); FacadeTestRunState result = TestRunner.Run(new AdapterFacadeTestListener(testListener), GetAssemblyPath(assembly), null, options); return FacadeUtils.ToTestRunState(result); }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { using (var helper = CreateHelper(testListener, assembly)) { if (member is Type) return helper.RunClass((Type)member); if (member is MethodInfo) return helper.RunMethod((MethodInfo)member); return TestRunState.NoTests; } }
public new TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { if (member.MemberType == MemberTypes.Constructor) { var where = "(cat == '.current')"; var result = this.Call<TestRunState>("run", testListener, assembly, where); if (result != TestRunState.NoTests) return result; return base.RunMember(testListener, assembly, member.DeclaringType); } return base.RunMember(testListener, assembly, member); }
/// <summary> /// Run selected tests asynchronously, notifying the listener interface as it progresses. /// </summary> /// <param name="listener">Interface to receive EventListener notifications.</param> /// <returns></returns> public override void StartRun(ITestListener listener) { #if !SILVERLIGHT && !NETCF _savedOut = Console.Out; _savedErr = Console.Error; Console.SetOut(new TextCapture(_savedOut)); Console.SetError(new TextCapture(_savedErr)); #endif Context.Dispatcher = new SimpleWorkItemDispatcher(); Context.Dispatcher.Dispatch(TopLevelWorkItem); }
public override void Execute(ITestListener listener) { if(_dataSource.Count > 0) { foreach(var dataRow in _dataSource) { if (!ValidateParameters(listener, dataRow)) { continue; } ExpectedException = dataRow.ExpectedException != null ? new ExpectedExceptionAttribute(dataRow.ExpectedException) : null; ExecuteInternal(listener, dataRow.Values); } } else { ReportError(listener, _dataSource.ErrorReason); } }
public TestRunState Run(ITestListener testListener, Func<Runner, AssemblyResult> run) { var listener = new TestDrivenListener(testListener); var runner = new Runner(listener); var result = run(runner); if (result.Total == 0) return TestRunState.NoTests; if (result.Failed > 0) return TestRunState.Failure; return TestRunState.Success; }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { using (var helper = CreateHelper(testListener, assembly)) { var type = member as Type; if (type != null) return helper.RunClass(type); var method = member as MethodInfo; if (method != null) return helper.RunMethod(method); return TestRunState.NoTests; } }
public FixtureRunner( IFixture fixture, ICollection<ITestCase> testCases, ITestListener listener) { if (fixture == null) throw new ArgumentNullException("fixture"); if (testCases == null) throw new ArgumentNullException("testCases"); if (listener == null) throw new ArgumentNullException("listener"); this.fixture = fixture; this.testCases = testCases; this.listener = listener; }
/// <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); }
// ITestRunner implementation TestRunState ITdNetTestRunner.RunAssembly(ITestListener listener, Assembly assembly) { string assemblyFilename = new Uri(assembly.CodeBase).LocalPath; try { using (ExecutorWrapper wrapper = new ExecutorWrapper(assemblyFilename, null, false)) { TdNetLogger logger = new TdNetLogger(listener, assembly); TestRunner runner = new TestRunner(wrapper, logger); return RunAssembly(runner); } } catch (ArgumentException) { return TestRunState.NoTests; } }
public TestRunState RunMember(ITestListener testListener, Assembly assembly, MemberInfo member) { Type type = member as Type; if (type != null) { TypeFixtureFilter filter = new TypeFixtureFilter(type.FullName); TypeFilterBase typeFilter = TypeFilters.Type(type.FullName); return Run(testListener, assembly, filter, new AnyRunPipeFilter(), typeFilter); } else { TypeFixtureFilter filter = new TypeFixtureFilter(member.DeclaringType.FullName); TypeFilterBase typeFilter = TypeFilters.Type(member.DeclaringType.FullName); ContainsMemberRunPipeFilter runPipeFilter = new ContainsMemberRunPipeFilter(member); return Run(testListener, assembly, filter, runPipeFilter, typeFilter); } }
private TestRunState Run( ITestListener testListener, Runner runner, TestFilter filter) { var state = TestRunState.NoTests; runner.RunAll(result =>{ testListener.TestFinished( new TestResult() { Name = String.Format("{0}.{1}",result.Test.Fixture.Name, result.Test.Name), FixtureType = ((Fixture)result.Test.Fixture).Type, StackTrace = result.Output, Method = ((Test)result.Test).Method, State = StateForResult(result.Kind), TimeSpan = result.EndTime - result.StartTime, }); if(state == TestRunState.NoTests){ switch (result.Kind) { case ResultKind.Fail: state = TestRunState.Failure; break; case ResultKind.Error: state = TestRunState.Error; break; default: state = TestRunState.Success; break; } } else if(state == TestRunState.Success || state == TestRunState.Failure){ switch (result.Kind) { case ResultKind.Fail: state = TestRunState.Failure; break; case ResultKind.Error: state = TestRunState.Error; break; } } }, filter); return state; }
/// <summary> /// Create the initial TestExecutionContext used to run tests /// </summary> /// <param name="listener">The ITestListener specified in the RunAsync call</param> protected override void CreateTestExecutionContext(ITestListener listener) { base.CreateTestExecutionContext(listener); int levelOfParallelization = GetLevelOfParallelization(); if (levelOfParallelization > 0) { Context.Dispatcher = new ParallelWorkItemDispatcher(levelOfParallelization); // 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)) Context.ParallelScope = (ParallelScope)LoadedTest.Properties.Get(PropertyNames.ParallelScope) & ~ParallelScope.Self; } else Context.Dispatcher = new SimpleWorkItemDispatcher(); }
private void RunTest(ITest test, ITestListener listener) { if (test.IsLeafTest()) { listener.TestStarted(test); } try { test.Run(); } catch (TestException x) { var reason = x.GetReason(); listener.TestFailed(test, reason == null ? x : reason); } catch (Exception failure) { listener.TestFailed(test, failure); } }
/// <summary> /// Initializes a new instance of the <see cref="TestExecutionContext"/> class. /// </summary> /// <param name="other">An existing instance of TestExecutionContext.</param> public TestExecutionContext(TestExecutionContext other) { _priorContext = other; this.CurrentTest = other.CurrentTest; this.CurrentResult = other.CurrentResult; this.TestObject = other.TestObject; this.WorkDirectory = other.WorkDirectory; _listener = other._listener; this.StopOnError = other.StopOnError; this.TestCaseTimeout = other.TestCaseTimeout; this.UpstreamActions = new List <ITestAction>(other.UpstreamActions); _currentCulture = CultureInfo.CurrentCulture; _currentUICulture = CultureInfo.CurrentUICulture; #if !NETCF && !SILVERLIGHT && !PORTABLE _currentPrincipal = other.CurrentPrincipal; #endif this.Dispatcher = other.Dispatcher; this.ParallelScope = other.ParallelScope; }
/// <summary> /// Execute a test run based on the aruments passed /// from Main. /// </summary> /// <param name="args">An array of arguments</param> public void Execute(string[] args) { this.commandLineOptions = new CommandLineOptions(); commandLineOptions.Parse(args); if (commandLineOptions.OutFile != null) { this.writer = new StreamWriter(commandLineOptions.OutFile); } TcpWriter tcpWriter = null; if (listener == TestListener.NULL && commandLineOptions.Port != -1) { tcpWriter = new TcpWriter(new IPEndPoint(IPAddress.Loopback, commandLineOptions.Port)); listener = new XmlTestListener(tcpWriter); } // Ensure we always dispose the socket correctly. using (tcpWriter) ExecuteWithListener(args, tcpWriter); }
/// <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); }
public ITestResult Run(ITestListener listener, ITestFilter filter) { try { IFormatter formatter = new BinaryFormatter(); formatter.Serialize(stream, filter); while (true) { object message = formatter.Deserialize(stream); if (message is TestStartedMessage tsmessage) { listener.TestStarted(tsmessage.Test); } else if (message is TestFinishedMessage tfmessage) { listener.TestFinished(tfmessage.TestResult); } else if (message is ExceptionMessage emessage) { throw emessage.Exception; } else if (message is ResultMessage rmessage) { return(rmessage.TestResult); } else { adb.Kill(); throw new Exception($"unknown message {message}"); } } } finally { adb.WaitForExit(); } }
///// <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) { TestExecutionContext context = new TestExecutionContext(); if (this.settings.Contains("WorkDirectory")) { context.WorkDirectory = (string)this.settings["WorkDirectory"]; } else #if NETCF || SILVERLIGHT || PORTABLE { context.WorkDirectory = Env.DocumentFolder; } #else { context.WorkDirectory = Environment.CurrentDirectory; } #endif context.Listener = listener; WorkItem workItem = loadedTest.CreateWorkItem(filter); workItem.Execute(context); #if PORTABLE while (workItem.State != WorkItemState.Complete) { long endTime = DateTime.Now.Ticks + TimeSpan.TicksPerMillisecond * 20; while (endTime > DateTime.Now.Ticks) { ; } } #else while (workItem.State != WorkItemState.Complete) { System.Threading.Thread.Sleep(5); } #endif return(workItem.Result); }
private TestRunState Run(Assembly assembly, MemberInfo member, ITestListener tddNetListener) { var locator = new StoryLocator { RootLocation = Path.GetDirectoryName(assembly.Location) }; var type = member as Type; var stories = (type == null) ? locator.LocateAllStories() : locator.LocateStoriesMatching(type); var results = NBehaveConfiguration .New .DontIsolateInAppDomain() .SetEventListener(new StoryRunnerEventListenerProxy(tddNetListener)) .SetScenarioFiles(stories) .SetAssemblies(new[] { assembly.Location }) .SetFilter(StoryRunnerFilter.GetFilter(member)) .Build() .Run(); return(GetTestRunState(results)); }
/// <summary> /// Execute a test run /// </summary> /// <param name="callingAssembly">The assembly from which tests are loaded</param> public int Execute(TextUI textUI, NUnitLiteOptions options) { _textUI = textUI; _options = options; _runner = new NUnitTestAssemblyRunner(new DefaultTestAssemblyBuilder()); try { #if !SILVERLIGHT && !PORTABLE if (!Directory.Exists(_options.WorkDirectory)) { Directory.CreateDirectory(_options.WorkDirectory); } #if !NETCF if (_options.TeamCity) { _teamCity = new TeamCityEventListener(); } #endif #endif if (_options.ShowVersion || !_options.NoHeader) { _textUI.DisplayHeader(); } if (_options.ShowHelp) { _textUI.DisplayHelp(); return(TextRunner.OK); } // We already showed version as a part of the header if (_options.ShowVersion) { return(TextRunner.OK); } if (_options.ErrorMessages.Count > 0) { _textUI.DisplayErrors(_options.ErrorMessages); _textUI.DisplayHelp(); return(TextRunner.INVALID_ARG); } _textUI.DisplayRuntimeEnvironment(); var testFile = _testAssembly != null ? AssemblyHelper.GetAssemblyPath(_testAssembly) : _options.InputFiles.Count > 0 ? _options.InputFiles[0] : null; if (testFile != null) { _textUI.DisplayTestFiles(new string[] { testFile }); if (_testAssembly == null) { _testAssembly = AssemblyHelper.Load(testFile); } } if (_options.WaitBeforeExit && _options.OutFile != null) { _textUI.DisplayWarning("Ignoring /wait option - only valid for Console"); } foreach (string nameOrPath in _options.InputFiles) { _assemblies.Add(AssemblyHelper.Load(nameOrPath)); } var runSettings = MakeRunSettings(_options); // We display the filters at this point so that any exception message // thrown by CreateTestFilter will be understandable. _textUI.DisplayTestFilters(); TestFilter filter = CreateTestFilter(_options); _runner.Load(_testAssembly, runSettings); return(_options.Explore ? ExploreTests() : RunTests(filter, runSettings)); } catch (FileNotFoundException ex) { _textUI.DisplayError(ex.Message); return(FILE_NOT_FOUND); } catch (Exception ex) { _textUI.DisplayError(ex.ToString()); return(UNEXPECTED_ERROR); } #if !SILVERLIGHT finally { if (_options.WaitBeforeExit) { _textUI.WaitForUser("Press Enter key to continue . . ."); } } #endif }
public CompositeTestListener(ITestListener listener1, ITestListener listener2) { _listener1 = listener1; _listener2 = listener2; }
public void RegisterTestListener(ITestListener testListener) { testListeners.Register(testListener); }
/// <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) { RunAsync(listener, filter); WaitForCompletion(Timeout.Infinite); return(Result); }
public TdNetLogger(ITestListener listener, Assembly assembly) { this.listener = listener; this.assembly = assembly; }
public ResultVisitor(ITestListener listener) { TestListener = listener; TestRunState = TestRunState.NoTests; }
public PortableUI(ITestListener listener, Assembly testAssembly) { this.runner = new NUnitLiteTestAssemblyRunner(new NUnitLiteTestAssemblyBuilder()); this.listener = listener; this.testAssembly = testAssembly; }
public TestDrivenListener(ITestListener tdnet) { this.tdnet = tdnet; }
TestRunState ITestRunner.RunMember(ITestListener tddNetListener, Assembly assembly, MemberInfo member) { //return Run(assembly, member, tddNetListener); return(TestRunState.NoTests); }
TestRunState ITestRunner.RunAssembly(ITestListener tddNetListener, Assembly assembly) { return(TestRunState.NoTests); //return Run(assembly, null, tddNetListener); }
public override TdNetRunnerHelper CreateHelper(ITestListener testListener, Assembly assembly) { return(Helper); }
public void UnregisterTestListener(ITestListener testListener) { testListeners.Unregister(testListener); }
///// <summary> ///// Gets a value indicating whether this event is delivered synchronously by the NUnit <see cref="EventPump"/>. ///// <para> ///// If <c>true</c>, and if <see cref="EventQueue.SetWaitHandleForSynchronizedEvents"/> has been used to ///// set a WaitHandle, <see cref="EventQueue.Enqueue"/> blocks its calling thread until the <see cref="EventPump"/> ///// thread has delivered the event and sets the WaitHandle. ///// </para> ///// </summary> // Keeping this as a synchronous until we rewrite using multiple autoresetevents //public override bool IsSynchronous //{ // get // { // return true; // } //} /// <summary> /// Calls TestStarted on the specified listener. /// </summary> /// <param name="listener">The listener.</param> public override void Send(ITestListener listener) { listener.TestStarted(this.test); }
///// <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> /// Constructor /// </summary> /// <param name="eventListener">The EventListener to receive events</param> /// <param name="events">The event queue to pull events from</param> public EventPump(ITestListener eventListener, EventQueue events) { _eventListener = eventListener; _events = events; }
public void TestSetup() { events = new EventAggregator(); listener = MockRepository.GenerateStrictMock <ITestListener>(); }
/// <summary> /// Initializes a new instance of the <see cref="EnduranceTest" /> class. /// </summary> /// <param name="ergometer">The ergometer from which to get measurements.</param> /// <param name="patient">The patient who's being tested.</param> /// <param name="listener">The listener the test replies to.</param> public EnduranceTest(Ergometer ergometer, Patient patient, ITestListener listener) { _ergometer = ergometer; _listener = listener; _patient = patient; }
/// <summary> /// The Send method is implemented by derived classes to send the event to the specified listener. /// </summary> /// <param name="listener">The listener.</param> abstract public void Send(ITestListener listener);
// Internal Execute depends on _textUI and _options having been set already. private int Execute() { _runner = new NUnitTestAssemblyRunner(new DefaultTestAssemblyBuilder()); InitializeInternalTrace(); try { if (!Directory.Exists(_options.WorkDirectory)) { Directory.CreateDirectory(_options.WorkDirectory); } if (_options.TeamCity) { _teamCity = new TeamCityEventListener(_textUI.Writer); } if (_options.ShowVersion || !_options.NoHeader) { _textUI.DisplayHeader(); } if (_options.ShowHelp) { _textUI.DisplayHelp(); return(TextRunner.OK); } // We already showed version as a part of the header if (_options.ShowVersion) { return(TextRunner.OK); } if (_options.ErrorMessages.Count > 0) { _textUI.DisplayErrors(_options.ErrorMessages); _textUI.Writer.WriteLine(); _textUI.DisplayHelp(); return(TextRunner.INVALID_ARG); } if (_testAssembly == null && _options.InputFile == null) { _textUI.DisplayError("No test assembly was specified."); _textUI.Writer.WriteLine(); _textUI.DisplayHelp(); return(TextRunner.OK); } _textUI.DisplayRuntimeEnvironment(); var testFile = _testAssembly != null ? AssemblyHelper.GetAssemblyPath(_testAssembly) : _options.InputFile; _textUI.DisplayTestFiles(new string[] { testFile }); if (_testAssembly == null) { _testAssembly = AssemblyHelper.Load(testFile); } if (_options.WaitBeforeExit && _options.OutFile != null) { _textUI.DisplayWarning("Ignoring /wait option - only valid for Console"); } var runSettings = MakeRunSettings(_options); // We display the filters at this point so that any exception message // thrown by CreateTestFilter will be understandable. _textUI.DisplayTestFilters(); TestFilter filter = CreateTestFilter(_options); _runner.Load(_testAssembly, runSettings); return(_options.Explore ? ExploreTests(filter) : RunTests(filter, runSettings)); } catch (FileNotFoundException ex) { _textUI.DisplayError(ex.Message); return(FILE_NOT_FOUND); } catch (Exception ex) { _textUI.DisplayError(ex.ToString()); return(UNEXPECTED_ERROR); } finally { if (_options.WaitBeforeExit) { _textUI.WaitForUser("Press Enter key to continue . . ."); } } }
/// <summary> /// Calls TestFinished on the specified listener. /// </summary> /// <param name="listener">The listener.</param> public override void Send(ITestListener listener) { listener.TestFinished(this.result); }
public TestRunState RunNamespace(ITestListener testListener, Assembly assembly, string ns) { return(Run(testListener, runner => runner.RunNamespace(assembly, ns))); }
public TestListenerIntercepter(ITestListener defaultListener) { DefaultListener = defaultListener; Outputs = new List <string>(); }
/// <summary> /// Initiate the test run /// </summary> public abstract void StartRun(ITestListener listener);
/// <summary> /// Constructor /// </summary> /// <param name="eventListener">The EventListener to receive events</param> /// <param name="events">The event queue to pull events from</param> public EventPump(ITestListener eventListener, EventQueue events) { this.eventListener = eventListener; this.events = events; this.events.SetWaitHandleForSynchronizedEvents(this.synchronousEventSent); }