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