public TestResult Run (EventListener listener, ITestFilter filter, string path, string suiteName, List<string> supportAssemblies, string testRunnerType, string testRunnerAssembly)
{
InitSupportAssemblies (supportAssemblies);
if (filter == null)
filter = TestFilter.Empty;
TestRunner tr;
if (!string.IsNullOrEmpty (testRunnerType)) {
Type runnerType;
if (string.IsNullOrEmpty (testRunnerAssembly))
runnerType = Type.GetType (testRunnerType, true);
else {
var asm = Assembly.LoadFrom (testRunnerAssembly);
runnerType = asm.GetType (testRunnerType);
}
tr = (TestRunner)Activator.CreateInstance (runnerType);
} else
tr = new RemoteTestRunner ();
TestPackage package = new TestPackage (path);
if (!string.IsNullOrEmpty (suiteName))
package.TestName = suiteName;
tr.Load (package);
return tr.Run (listener, filter, false, LoggingThreshold.All);
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using (new global::NUnit.Core.TestContext())
{
var testResult = new TestResult(this);
Log.Debug("Test Starting: " + TestName.FullName);
listener.TestStarted(TestName);
var stopwatch = new Stopwatch();
stopwatch.Start();
switch (RunState)
{
case RunState.Runnable:
case RunState.Explicit:
DoTest(_test, testResult);
break;
case RunState.NotRunnable:
testResult.Invalid(IgnoreReason);
break;
case RunState.Ignored:
testResult.Ignore(IgnoreReason);
break;
default:
testResult.Skip(IgnoreReason);
break;
}
stopwatch.Stop();
testResult.Time = stopwatch.Elapsed.Seconds;
listener.TestFinished(testResult);
return testResult;
}
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
var successCount = 0;
TestResult failureResult = null;
for (var i = 0; i < this.tryCount; i++)
{
var result = base.Run(listener, filter);
if (!TestFailed(result))
{
if (i == 0)
{
return result;
}
if (++successCount >= this.requiredPassCount)
{
return result;
}
}
else
{
failureResult = result;
}
}
return failureResult;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.TestStarted(base.TestName);
long ticks = DateTime.Now.Ticks;
var testResult = new TestResultShim();
Exception existingError = null;
_globalSetup.PrepareForTestPosition(Position, out existingError);
if (existingError != null)
{
TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), existingError, null, TestResultShim.Site.SetUp);
}
else
{
List<string> traceMessages = null;
try
{
RunTestMethod(testResult, out traceMessages);
}
catch (Exception e)
{
var globalTraceMessages = _globalSetup.GetTraceMessages();
TestResultUtil.Error(testResult, TestExtensions.GetMultilineName(this), e, globalTraceMessages.Concat(traceMessages));
}
}
var nunitTestResult = new TestResult(this);
NativeTestResult.ApplyToNunitResult(testResult, nunitTestResult);
nunitTestResult.Time = ((DateTime.Now.Ticks - ticks)) / 10000000.0;
listener.TestFinished(nunitTestResult);
return nunitTestResult;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
var result = new TestResult(this);
lock (testClosure) {
try {
testClosure.TestMethod();
TestNonExceptionCondition(result);
} catch (IgnoreException iex) {
result.Ignore(iex.Message);
} catch (InconclusiveException icex) {
result.Invalid(icex.Message);
} catch (Exception ex) {
TestExceptionCondition(result, ex);
}
try {
testClosure.TearDown();
} catch (Exception ex) {
result.Failure("Exception in tear-down: "+ex.Message, ex.StackTrace);
}
}
listener.TestFinished(result);
return result;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.TestStarted(base.TestName);
long ticks = DateTime.Now.Ticks;
TestResult testResult = new TestResult(this);
Exception existingError = null;
_globalSetup.PrepareForTestPosition(Position, out existingError);
if (existingError != null)
{
TestResultUtil.Error(testResult, existingError, null, FailureSite.SetUp);
}
else
{
List<string> traceMessages = null;
try
{
RunTestMethod(testResult, out traceMessages);
}
catch (Exception e)
{
var globalTraceMessages = _globalSetup.GetTraceMessages();
TestResultUtil.Error(testResult, e, globalTraceMessages.Concat(traceMessages));
}
}
double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0;
testResult.Time = num3;
listener.TestFinished(testResult);
return testResult;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using ( new DirectorySwapper( AssemblyHelper.GetDirectoryName( FixtureType.Assembly ) ) )
{
return base.Run(listener, filter);
}
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.SuiteStarted(this.TestName);
var suiteListener = new MuteSuiteListener(listener);
var fixtureResult = base.Run(suiteListener, TestFilter.Empty);
var testResult = fixtureResult.Results[0] as TestResult;
if (testResult != null)
{
if (testResult.IsFailure || testResult.IsError)
{
fixtureResult.SetResult(testResult.ResultState,
testResult.Message,
testResult.StackTrace);
}
if (testResult.IsSuccess)
{
fixtureResult.Success();
}
}
listener.SuiteFinished(fixtureResult);
return fixtureResult;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
using ( new DirectorySwapper( Path.GetDirectoryName( TestFixtureBuilder.GetAssemblyPath( FixtureType ) ) ) )
{
return base.Run(listener, filter);
}
}
/// <summary>
/// Override Run, setting Fixture to that of the Parent.
/// </summary>
/// <param name="listener"></param>
/// <param name="filter"></param>
/// <returns></returns>
public override TestResult Run(EventListener listener, ITestFilter filter)
{
if (this.Parent != null)
{
this.Fixture = this.Parent.Fixture;
TestSuite suite = this.Parent as TestSuite;
if (suite != null)
{
this.setUpMethods = suite.GetSetUpMethods();
this.tearDownMethods = suite.GetTearDownMethods();
}
}
// DYNAMIC: Get the parameters, and add the methods here.
TestResult result = base.Run(listener, filter);
if (this.isTheory && result.ResultState == ResultState.Inconclusive)
result.SetResult(
ResultState.Failure,
this.TestCount == 0
? "No test cases were provided"
: "All test cases were inconclusive",
null);
this.Fixture = null;
this.setUpMethods = null;
this.tearDownMethods = null;
return result;
}
public override int CountTestCases( ITestFilter filter )
{
if (filter.Pass(this))
return 1;
return 0;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
TestSuiteResult suite_result = new TestSuiteResult (new TestInfo (this), TestName.FullName);
DebuggerTestHost host = DebuggerTestHost.Create ();
if (host == null) {
TestCaseResult error = new TestCaseResult (new TestInfo (this));
string msg = String.Format ("Failed to create DebuggerTestHost in {0}", FixtureType.Name);
error.Failure (msg, null, FailureSite.Parent);
suite_result.AddResult (error);
return suite_result;
}
int timeout;
if (Attribute.Timeout != 0)
timeout = Attribute.Timeout;
else
timeout = DebuggerTestAddIn.DefaultTimeout;
int repeat = 1;
if (Attribute.Repeat != 0)
repeat = Attribute.Repeat;
try {
for (int i = 0; i < repeat; i++) {
if (!host.Run (new TestInfo (this), suite_result, Type.AssemblyQualifiedName, listener, filter, timeout))
break;
}
return suite_result;
} finally {
host.Dispose ();
}
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
if (this.Parent != null)
this.Fixture = this.Parent.Fixture;
return base.Run(listener, filter);
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
test.Parent = Parent;
TestResult result = null;
for (var i = 1; i < retryCount; i++)
{
try
{
result = test.Run(listener, filter);
if (result.IsFailure || result.IsError)
{
var message = string.Format("Rerunning '{0}'", TestName);
Log.Info(message); Console.WriteLine(message);
result = test.Run(listener, filter);
}
}
// In Case SetUp or TearDown failed
catch (Exception e)
{
Log.Info(e.Message); Console.WriteLine(e);
}
}
return result;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
Uri uri = new Uri( FixtureType.Assembly.CodeBase );
using ( new DirectorySwapper( Path.GetDirectoryName( uri.LocalPath ) ) )
{
return base.Run(listener, filter);
}
}
public UnitTestResult Run (IRemoteEventListener listener, ITestFilter filter, string path, string suiteName, List<string> supportAssemblies)
{
NUnitTestRunner runner = GetRunner (path);
EventListenerWrapper listenerWrapper = listener != null ? new EventListenerWrapper (listener) : null;
TestResult res = runner.Run (listenerWrapper, filter, path, suiteName, supportAssemblies);
return listenerWrapper.GetLocalTestResult (res);
}
static public WorkItem CreateWorkItem(Test test, TestExecutionContext context, ITestFilter filter)
{
TestSuite suite = test as TestSuite;
if (suite != null)
return new CompositeWorkItem(suite, context, filter);
else
return new SimpleWorkItem((TestMethod)test, context);
}
public static WorkItem CreateWorkItem(Test test, TestExecutionContext context, ITestFilter filter)
{
TestSuite suite = test as TestSuite;
if (suite != null && (suite.RunState == RunState.Runnable || suite.RunState == RunState.Explicit))
return new CompositeWorkItem(suite, context, filter);
else
return new SimpleWorkItem(test, context);
}
/// <summary>
/// Creates a work item.
/// </summary>
/// <param name="test">The test for which this WorkItem is being created.</param>
/// <param name="filter">The filter to be used in selecting any child Tests.</param>
/// <returns></returns>
static public WorkItem CreateWorkItem(ITest test, ITestFilter filter)
{
TestSuite suite = test as TestSuite;
if (suite != null)
return new CompositeWorkItem(suite, filter);
else
return new SimpleWorkItem((TestMethod)test, filter);
}
/// <summary>
/// Construct a CompositeWorkItem for executing a test suite
/// using a filter to select child tests.
/// </summary>
/// <param name="suite">The TestSuite to be executed</param>
/// <param name="context">The execution context to be used</param>
/// <param name="childFilter">A filter used to select child tests</param>
public CompositeWorkItem(TestSuite suite, TestExecutionContext context, ITestFilter childFilter)
: base(suite, context)
{
_suite = suite;
_setupCommand = suite.GetOneTimeSetUpCommand();
_teardownCommand = suite.GetOneTimeTearDownCommand();
_childFilter = childFilter;
}
public TouchRunner (UIWindow window)
{
if (window == null)
throw new ArgumentNullException ("window");
this.window = window;
filter = TestFilter.Empty;
}
public TestRunAction BuildTestRunAction(string name, int index, ITestFilter filter)
{
return new TestRunAction
{
Name = name,
Index = index,
RunTests = () => BuildFilteredBlockingProcess(name, filter)
};
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.TestStarted(base.TestName);
long ticks = DateTime.Now.Ticks;
TestResult result = new TestResult(this);
result.SetResult(ResultState.NotRunnable, "Specification not implemented.", null, FailureSite.Test);
double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0;
result.Time = num3;
listener.TestFinished(result);
return result;
}
public override TestResult Run(EventListener listener, ITestFilter filter)
{
listener.TestStarted(base.TestName);
long ticks = DateTime.Now.Ticks;
TestResult testResult = new TestResult(this);
testResult.Failure(_reason, _stackTrace);
double num3 = ((double)(DateTime.Now.Ticks - ticks)) / 10000000.0;
testResult.Time = num3;
listener.TestFinished(testResult);
return testResult;
}
public TestRunAction BuildTestRunAction(string name, int index, ITestFilter filter)
{
//var anyOthers = new CategoryRunner(_assemblyLocation, other, "all", outputPath, countdownEvent);
var runner = new CategoryRunner(_assemblyLocation, filter, BuildOutputXmlPath(name));
return new TestRunAction
{
Name = name,
Index = index,
RunTests = () => runner.Execute()
};
}
public CategoryRunner(
string assemblyLocation,
ITestFilter filter,
string outputXmlFile)
{
_assemblyLocation = assemblyLocation;
Filter = filter;
_outputXmlFile = outputXmlFile;
MarkAsInitalized();
}
/// <summary>
/// Create a WorkItem appropriate for the test to be run
/// </summary>
/// <param name="test">The test to be executed</param>
/// <param name="context">The execution context in which the test will be run</param>
/// <param name="filter">A filter for selecting chind tests</param>
/// <returns></returns>
public static WorkItem CreateWorkItem(Test test, TestExecutionContext context, ITestFilter filter)
{
if (test.RunState != RunState.Runnable && test.RunState != RunState.Explicit)
return new SimpleWorkItem(new SkipCommand(test), context);
TestSuite suite = test as TestSuite;
if (suite != null)
return new CompositeWorkItem(suite, context, filter);
return new SimpleWorkItem((TestMethod)test, context);
}
public TestResult Run(string test_name, EventListener listener, ITestFilter filter)
{
try {
Type test_type = Type.GetType (test_name, true);
NUnit.Core.Test test = builder.BuildFrom (test_type);
TestResult result = test.Run (listener, filter);
return result;
} catch (Exception ex) {
Console.WriteLine ("RUN EX: {0}", ex);
throw;
}
}
public override TestResult Run( EventListener listener, ITestFilter filter )
{
NTrace.Debug( "Running test synchronously" );
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture( queue );
using( EventPump pump = new EventPump( listener, queue.Events, true ) )
{
pump.Start();
return base.Run( queue, filter );
}
}
public override void BeginRun( EventListener listener, ITestFilter filter )
{
NTrace.Debug( "Running test asynchronously" );
QueuingEventListener queue = new QueuingEventListener();
StartTextCapture( queue );
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 );
}
protected override UnityWorkItem Create(TestMethod method, ITestFilter filter, ITest loadedTest)
{
return(new EditorEnumeratorTestWorkItem(method, filter));
}
/// <summary> /// Creates a WorkItem for executing this test. /// </summary> /// <param name="childFilter">A filter to be used in selecting child tests</param> /// <returns>A new WorkItem</returns> public abstract WorkItem CreateWorkItem(ITestFilter childFilter, FinallyDelegate finD);
/// <summary>
/// Construct a not filter on another filter
/// </summary>
/// <param name="baseFilter">The filter to be negated</param>
public NotFilter(ITestFilter baseFilter)
{
this.baseFilter = baseFilter;
}
public bool Run(TestInfo test, TestSuiteResult suite_result, string test_name, EventListener listener, ITestFilter filter, int timeout)
{
listener = new ProxyListener(listener);
TestRunnerDelegate runner = new TestRunnerDelegate(delegate {
return(server.Run(test_name, listener, filter));
});
IAsyncResult ar = runner.BeginInvoke(test_name, null, filter, null, null);
if (!ar.AsyncWaitHandle.WaitOne(timeout) || !ar.IsCompleted)
{
TestCaseResult error = new TestCaseResult(test);
string msg = String.Format("Timeout after {0} ms", timeout);
error.Failure(msg, null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
}
try {
TestResult result = runner.EndInvoke(ar);
if (result != null)
{
suite_result.AddResult(result);
return(true);
}
TestCaseResult error = new TestCaseResult(test);
error.Failure("Unknown error", null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
} catch (Exception ex) {
TestCaseResult error = new TestCaseResult(test);
string msg = String.Format("Unknown exception: {0}", ex);
error.Failure(msg, null, FailureSite.Parent);
suite_result.AddResult(error);
return(false);
}
}
/// <summary>
/// Creates a filtered copy of the test suite.
/// </summary>
/// <param name="filter">Determines which descendants are copied.</param>
public override TestSuite Copy(ITestFilter filter)
{
return(new SetUpFixture(this, filter));
}
/// <summary>
/// Construct a simple work item for a test.
/// </summary>
/// <param name="test">The test to be executed</param>
/// <param name="filter">The filter used to select this test</param>
public SimpleWorkItem(TestMethod test, ITestFilter filter)
: base(test, filter)
{
_testMethod = test;
}
public override async Task <IEnumerable <string> > GetCategories(ITestFilter filter)
{
var categoryList = await Task.WhenAll(Runners.Select(r => r.GetCategories(filter)));
return(categoryList.SelectMany(r => r).Distinct());
}
/// <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);
}
private void MarkTestsNotRun(
IList tests, ResultState resultState, string ignoreReason, TestResult suiteResult, EventListener listener, ITestFilter filter)
{
foreach (Test test in ArrayList.Synchronized(tests))
{
if (filter.Pass(test))
{
MarkTestNotRun(test, resultState, ignoreReason, suiteResult, listener, filter);
}
}
}
private void MarkTestNotRun(
Test test, ResultState resultState, string ignoreReason, TestResult suiteResult, EventListener listener, ITestFilter filter)
{
if (test is TestSuite)
{
listener.SuiteStarted(test.TestName);
TestResult result = new TestResult(new TestInfo(test));
result.SetResult(resultState, ignoreReason, null);
MarkTestsNotRun(test.Tests, resultState, ignoreReason, suiteResult, listener, filter);
suiteResult.AddResult(result);
listener.SuiteFinished(result);
}
else
{
listener.TestStarted(test.TestName);
TestResult result = new TestResult(new TestInfo(test));
result.SetResult(resultState, ignoreReason, null);
suiteResult.AddResult(result);
listener.TestFinished(result);
}
}
private void MarkAllTestsInvalid(TestResult suiteResult, EventListener listener, ITestFilter filter)
{
suiteResult.Invalid(this.IgnoreReason);
MarkTestsNotRun(this.Tests, ResultState.NotRunnable, this.IgnoreReason, suiteResult, listener, filter);
}
private void IgnoreAllTests(TestResult suiteResult, EventListener listener, ITestFilter filter)
{
suiteResult.Ignore(this.IgnoreReason);
MarkTestsNotRun(this.Tests, ResultState.Ignored, this.IgnoreReason, suiteResult, listener, filter);
}
/// <summary>
/// Construct a CompositeWorkItem for executing a test suite
/// using a filter to select child tests.
/// </summary>
/// <param name="suite">The TestSuite to be executed</param>
/// <param name="childFilter">A filter used to select child tests</param>
public CompositeWorkItem(TestSuite suite, ITestFilter childFilter)
: base(suite, childFilter)
{
_suite = suite;
_suiteResult = Result as TestSuiteResult;
}
/// <summary>
/// Copy-constructor style to create a filtered copy of the test assemblies
/// test cases
/// </summary>
/// <param name="assembly"></param>
/// <param name="filter"></param>
public TestAssembly(TestAssembly assembly, ITestFilter filter)
: base(assembly as TestSuite, filter)
{
this.Name = assembly.Name;
this.Assembly = assembly.Assembly;
}
public override async Task <int> GetTestCount(ITestFilter filter)
{
var countList = await Task.WhenAll(Runners.Select(r => r.GetTestCount(filter)));
return(countList.Sum());
}
/// <summary> /// Runs the test under a particular filter, sending /// notifications to a listener. /// </summary> /// <param name="listener">An event listener to receive notifications</param> /// <param name="filter">A filter used in running the test</param> /// <returns></returns> public abstract TestResult Run(EventListener listener, ITestFilter filter);
public override Task <IEnumerable <string> > GetCategories(ITestFilter filter)
{
return(Task.FromResult(Enumerable.Empty <string>()));
}
public int CountTestCases(string filter)
{
ITestFilter v2Filter = CreateNUnit2TestFilter(filter);
return(_runner.CountTestCases(v2Filter));
}
public DefaultTestWorkItem(TestMethod test, ITestFilter filter)
: base(test, null)
{
_command = TestCommandBuilder.BuildTestCommand(test, filter);
}
public override TestSuite Copy(ITestFilter filter)
{
return(new ParameterizedMethodSuite(this, filter));
}
/// <summary>
/// Creates a copy of the given suite with only the descendants that pass the specified filter.
/// </summary>
/// <param name="setUpFixture">The <see cref="SetUpFixture"/> to copy.</param>
/// <param name="filter">Determines which descendants are copied.</param>
public SetUpFixture(SetUpFixture setUpFixture, ITestFilter filter)
: base(setUpFixture, filter)
{
}
public TestExplorer(IExplorerView view, IEventAggregator events, ITestFilterBar filterBar, ITestFilter filter,
IIconService icons)
{
_view = view;
_events = events;
_filter = filter;
_icons = icons;
if (filterBar != null)
{
filterBar.Observer = this;
}
_navigator = new SuiteNavigator
{
TestFilter = _filter.Matches,
SuiteFilter = _filter.Matches
};
}
/// <summary>
/// Creates a WorkItem for executing this test.
/// </summary>
/// <param name="childFilter">A filter to be used in selecting child tests</param>
/// <returns>A new WorkItem</returns>
public override WorkItem CreateWorkItem(ITestFilter childFilter)
{
// For simple test cases, we ignore the filter
return(new SimpleWorkItem(this));
}
public static TestResult Run(TestRunner runner, EventCollector listener, ITestFilter filter)
{
return(runner.Run(listener, filter));
}
/// <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);
}
if (!commandLineOptions.NoHeader)
{
WriteHeader(this.writer);
}
if (commandLineOptions.ShowHelp)
{
writer.Write(commandLineOptions.HelpText);
}
else if (commandLineOptions.Error)
{
writer.WriteLine(commandLineOptions.ErrorMessage);
writer.WriteLine(commandLineOptions.HelpText);
}
else
{
WriteRuntimeEnvironment(this.writer);
if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
{
writer.WriteLine("Ignoring /wait option - only valid for Console");
}
#if SILVERLIGHT
IDictionary loadOptions = new System.Collections.Generic.Dictionary <string, string>();
#else
IDictionary loadOptions = new Hashtable();
#endif
//if (options.Load.Count > 0)
// loadOptions["LOAD"] = options.Load;
//IDictionary runOptions = new Hashtable();
//if (commandLineOptions.TestCount > 0)
// runOptions["RUN"] = commandLineOptions.Tests;
ITestFilter filter = commandLineOptions.TestCount > 0
? new SimpleNameFilter(commandLineOptions.Tests)
: TestFilter.Empty;
try
{
foreach (string name in commandLineOptions.Parameters)
{
try {
assemblies.Add(Assembly.LoadFrom(name));
}
catch (FileNotFoundException /* e*/) {
assemblies.Add(Assembly.Load(name));
}
}
if (assemblies.Count == 0)
{
// NOTE: Execute must be directly called from the
// test assembly in order for the mechanism to work.
Assembly callingAssembly = Assembly.GetCallingAssembly();
assemblies.Add(callingAssembly);
}
// TODO: For now, ignore all but first assembly
Assembly assembly = assemblies[0] as Assembly;
Randomizer.InitialSeed = commandLineOptions.InitialSeed;
if (!runner.Load(assembly, loadOptions))
{
AssemblyName assemblyName = AssemblyHelper.GetAssemblyName(assembly);
Console.WriteLine("No tests found in assembly {0}", assemblyName.Name);
return;
}
if (commandLineOptions.Explore)
{
ExploreTests();
}
else
{
if (commandLineOptions.Include != null && commandLineOptions.Include != string.Empty)
{
TestFilter includeFilter = new SimpleCategoryExpression(commandLineOptions.Include).Filter;
if (filter.IsEmpty)
{
filter = includeFilter;
}
else
{
filter = new AndFilter(filter, includeFilter);
}
}
if (commandLineOptions.Exclude != null && commandLineOptions.Exclude != string.Empty)
{
TestFilter excludeFilter = new NotFilter(new SimpleCategoryExpression(commandLineOptions.Exclude).Filter);
if (filter.IsEmpty)
{
filter = excludeFilter;
}
else if (filter is AndFilter)
{
((AndFilter)filter).Add(excludeFilter);
}
else
{
filter = new AndFilter(filter, excludeFilter);
}
}
#if MONO
filter = Xamarin.BabysitterSupport.AddBabysitterFilter(filter);
#endif
RunTests(filter);
}
}
catch (FileNotFoundException ex)
{
Failure = true;
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
Failure = true;
writer.WriteLine(ex.ToString());
}
finally
{
if (commandLineOptions.OutFile == null)
{
if (commandLineOptions.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
writer.Close();
}
}
}
}
public void RunOnly(string testName)
{
var nameFilter = new SimpleNameFilter(testName);
filter = And(filter, nameFilter);
}
private int BuildFilteredBlockingProcess(string category, ITestFilter filter)
{
var args = BuildParameterString(BuildOutputXmlPath(category), ToParameterString(filter));
return(BuildBlockingProcess(args));
}
public void Exclude(string categories)
{
var excludeFilter = new NotFilter(new SimpleCategoryExpression(categories).Filter);
filter = And(filter, excludeFilter);
}
/// <summary>
/// Adds a filter to the list of filters
/// </summary>
/// <param name="filter">The filter to be added</param>
public void Add(ITestFilter filter)
{
this.filters.Add(filter);
}
public void Run(ITestFilter testFilter = null)
{
testFilter = testFilter ?? TestFilter.Empty;
// "controls" is the cross-platform test assembly
#if NETSTANDARD2_0
var controls = Assembly.GetExecutingAssembly();
#else
var controls = typeof(PlatformTestRunner).GetTypeInfo().Assembly;
#endif
var platformTestSettings = DependencyService.Resolve <IPlatformTestSettings>();
// "platform" is the native assembly (ControGallery.iOS, ControlGallery.Android, etc.)
Assembly platform = platformTestSettings.Assembly;
var testRunSettings = platformTestSettings.TestRunSettings;
var runner = new NUnitTestAssemblyRunner(new DefaultTestAssemblyBuilder());
bool runOnMainThread = false;
if (testRunSettings.TryGetValue(FrameworkPackageSettings.RunOnMainThread, out object runOnMainSetting))
{
runOnMainThread = (bool)runOnMainSetting;
}
try
{
if (runOnMainThread)
{
// FrameworkPackageSettings.RunOnMainThread will force all the tests to run sequentially on the thread
// they are started on; we have to do this for iOS to avoid cross-thread exceptions when updating
// renderer properties. It's a less nice runner experience, because we don't get progress updates
// while it runs, but that's life. Anyway, we push the test runs onto the main thread and wait.
Device.BeginInvokeOnMainThread(() =>
{
runner.Load(controls, testRunSettings);
runner.Run(_testListener, testFilter);
runner.Load(platform, testRunSettings);
runner.Run(_testListener, testFilter);
});
}
else
{
// So far, Android lets us get away with running tests asynchronously, so we get
// progress updates as they run. This should be our default until we run into cross-thread
// or "not on the UI thread" issues with a platform, at which point we need to set RunOnMainThread
// like we do for iOS
runner.Load(controls, testRunSettings);
runner.Run(_testListener, testFilter);
runner.Load(platform, testRunSettings);
runner.Run(_testListener, testFilter);
}
}
catch (Exception ex)
{
MessagingCenter.Send(ex, "TestRunnerError");
}
}
