/// <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)
{
// NOTE: This must be directly called from the
// test assembly in order for the mechanism to work.
Assembly callingAssembly = Assembly.GetCallingAssembly();
this.options = ProcessArguments( args );
if (!options.Help && !options.Error)
{
if (options.Wait && !(this is ConsoleUI))
writer.WriteLine("Ignoring /wait option - only valid for Console");
try
{
foreach (string name in options.Parameters)
assemblies.Add(Assembly.Load(name));
if (assemblies.Count == 0)
assemblies.Add(callingAssembly);
foreach (Assembly assembly in assemblies)
if (options.TestCount == 0)
Run(assembly);
else
Run(assembly, options.Tests);
}
catch (TestRunnerException ex)
{
writer.WriteLine(ex.Message);
}
catch (FileNotFoundException ex)
{
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
writer.WriteLine(ex.ToString());
}
finally
{
if (options.Wait && this is ConsoleUI)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
}
}
public static int Main()
{
CommandLineOptions options = new CommandLineOptions();
ConsoleUI runner = new ConsoleUI(options, Console.Out);
try
{
TestResult result = runner.Run(Assembly.GetExecutingAssembly());
if (result.IsFailure || result.IsError)
return 1;
else
return 0;
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.ToString());
return 1;
}
}
/// <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)
{
// NOTE: Execute must be directly called from the
// test assembly in order for the mechanism to work.
Assembly callingAssembly = Assembly.GetCallingAssembly();
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");
// We only have one commandline option that has to be passed
// to the runner, so we do it here for convenience.
var runnerSettings = new Dictionary<string, object>();
Randomizer.InitialSeed = commandLineOptions.InitialSeed;
TestFilter filter = commandLineOptions.TestCount > 0
? new SimpleNameFilter(commandLineOptions.Tests)
: TestFilter.Empty;
try
{
foreach (string name in commandLineOptions.Parameters)
assemblies.Add(Assembly.Load(name));
if (assemblies.Count == 0)
assemblies.Add(callingAssembly);
// TODO: For now, ignore all but first assembly
Assembly assembly = assemblies[0];
//Randomizer.InitialSeed = commandLineOptions.InitialSeed;
if (runner.Load(assembly, runnerSettings) == null)
{
var 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);
}
RunTests(filter);
}
}
catch (FileNotFoundException ex)
{
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
writer.WriteLine(ex.ToString());
}
finally
{
if (commandLineOptions.OutFile == null)
{
if (commandLineOptions.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
writer.Close();
}
}
}
}
/// <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)
{
// NOTE: Execute must be directly called from the
// test assembly in order for the mechanism to work.
_options = new CommandLineOptions(args);
_workDirectory = _options.WorkDirectory;
if (_workDirectory == null)
_workDirectory = Environment.CurrentDirectory;
else if (!Directory.Exists(_workDirectory))
Directory.CreateDirectory(_workDirectory);
#if !SILVERLIGHT
if (_options.DisplayTeamCityServiceMessages)
_teamCity = new TeamCityEventListener();
if (_options.OutFile != null)
{
_outWriter = new StreamWriter(Path.Combine(_workDirectory, _options.OutFile));
Console.SetOut(_outWriter);
}
if (_options.ErrFile != null)
{
_errWriter = new StreamWriter(Path.Combine(_workDirectory, _options.ErrFile));
Console.SetError(_errWriter);
}
#endif
if (!_options.NoHeader)
WriteHeader(_outWriter);
if (_options.ShowHelp)
_outWriter.Write(_options.HelpText);
else if (_options.ErrorMessages.Count > 0)
{
foreach(string line in _options.ErrorMessages)
_outWriter.WriteLine(line);
_outWriter.WriteLine(_options.HelpText);
}
else
{
Assembly callingAssembly = Assembly.GetCallingAssembly();
// We must call this before creating the runner so that any internal logging is initialized
InternalTraceLevel level = (InternalTraceLevel)Enum.Parse(typeof(InternalTraceLevel), _options.InternalTraceLevel, true);
InitializeInternalTrace(callingAssembly.Location, level);
_runner = new NUnitLiteTestAssemblyRunner(new DefaultTestAssemblyBuilder());
DisplayRequestedOptions(_outWriter);
WriteRuntimeEnvironment(_outWriter);
if (_options.Wait && _options.OutFile != null)
_outWriter.WriteLine("Ignoring /wait option - only valid for Console");
var runSettings = MakeRunSettings(_options);
TestFilter filter = CreateTestFilter(_options);
try
{
foreach (string name in _options.InputFiles)
_assemblies.Add(Assembly.Load(name));
if (_assemblies.Count == 0)
_assemblies.Add(callingAssembly);
// TODO: For now, ignore all but first assembly
Assembly assembly = _assemblies[0];
//Randomizer.InitialSeed = _commandLineOptions.InitialSeed;
if (_runner.Load(assembly, runSettings) == null)
{
var assemblyName = AssemblyHelper.GetAssemblyName(assembly);
Console.WriteLine("No tests found in assembly {0}", assemblyName.Name);
return;
}
if (_options.Explore)
ExploreTests();
else
{
RunTests(filter);
}
}
catch (FileNotFoundException ex)
{
_outWriter.WriteLine(ex.Message);
}
catch (Exception ex)
{
_outWriter.WriteLine(ex.ToString());
}
finally
{
if (_options.OutFile == null)
{
if (_options.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
_outWriter.Close();
}
if (_options.ErrFile != null)
_errWriter.Close();
}
}
}
/// <summary>
/// Create the test filter for this run - public for testing
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public static TestFilter CreateTestFilter(CommandLineOptions options)
{
TestFilter namefilter = options.Tests.Count > 0
? new SimpleNameFilter(options.Tests)
: TestFilter.Empty;
TestFilter includeFilter = string.IsNullOrEmpty(options.Include)
? TestFilter.Empty
: new SimpleCategoryExpression(options.Include).Filter;
TestFilter excludeFilter = string.IsNullOrEmpty(options.Exclude)
? TestFilter.Empty
: new NotFilter(new SimpleCategoryExpression(options.Exclude).Filter);
TestFilter catFilter = includeFilter.IsEmpty
? excludeFilter
: excludeFilter.IsEmpty
? includeFilter
: new AndFilter(includeFilter, excludeFilter);
return namefilter.IsEmpty
? catFilter
: catFilter.IsEmpty
? namefilter
: new AndFilter(namefilter, catFilter);
}
/// <summary>
/// Make the settings for this run - this is public for testing
/// </summary>
public static Dictionary<string, object> MakeRunSettings(CommandLineOptions options)
{
// Transfer command line options to run settings
var runSettings = new Dictionary<string, object>();
if (options.InitialSeed >= 0)
runSettings[DriverSettings.RandomSeed] = options.InitialSeed;
if (options.WorkDirectory != null)
runSettings[DriverSettings.WorkDirectory] = Path.GetFullPath(options.WorkDirectory);
if (options.DefaultTimeout >= 0)
runSettings[DriverSettings.DefaultTimeout] = options.DefaultTimeout;
return runSettings;
}
/// <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)
{
// NOTE: Execute must be directly called from the
// test assembly in order for the mechanism to work.
Assembly callingAssembly = Assembly.GetCallingAssembly();
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)
assemblies.Add(Assembly.Load(name));
if (assemblies.Count == 0)
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);
}
RunTests(filter);
}
}
catch (FileNotFoundException ex)
{
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
writer.WriteLine(ex.ToString());
}
finally
{
if (commandLineOptions.OutFile == null)
{
if (commandLineOptions.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
writer.Close();
}
}
}
}
/// <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)
{
// NOTE: Execute must be directly called from the
// test assembly in order for the mechanism to work.
Assembly callingAssembly = Assembly.GetCallingAssembly();
this.commandLineOptions = new CommandLineOptions();
commandLineOptions.Parse(args);
if (commandLineOptions.OutFile != null)
this.writer = new StreamWriter(commandLineOptions.OutFile);
if (!commandLineOptions.NoHeader)
WriteHeader();
if (commandLineOptions.ShowHelp)
writer.Write(commandLineOptions.HelpText);
else if (commandLineOptions.Error)
{
writer.WriteLine(commandLineOptions.ErrorMessage);
writer.WriteLine(commandLineOptions.HelpText);
}
else
{
WriteRuntimeEnvironment();
if (commandLineOptions.Wait && commandLineOptions.OutFile != null)
writer.WriteLine("Ignoring /wait option - only valid for Console");
IDictionary loadOptions = new Hashtable();
//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)
assemblies.Add(Assembly.Load(name));
if (assemblies.Count == 0)
assemblies.Add(callingAssembly);
// TODO: For now, ignore all but first assembly
Assembly assembly = assemblies[0] as Assembly;
if (!runner.Load(assembly, loadOptions))
{
Console.WriteLine("No tests found in assembly {0}", assembly.GetName().Name);
return;
}
if (commandLineOptions.Explore)
ExploreTests();
else
RunTests(filter);
}
catch (FileNotFoundException ex)
{
writer.WriteLine(ex.Message);
}
catch (Exception ex)
{
writer.WriteLine(ex.ToString());
}
finally
{
if (commandLineOptions.OutFile == null)
{
if (commandLineOptions.Wait)
{
Console.WriteLine("Press Enter key to continue . . .");
Console.ReadLine();
}
}
else
{
writer.Close();
}
}
}
}
private CommandLineOptions ProcessArguments(string[] args)
{
this.options = new CommandLineOptions();
options.Parse(args);
if (!options.Nologo)
WriteCopyright();
if (options.Help)
writer.Write(options.HelpText);
else if (options.Error)
writer.WriteLine(options.ErrorMessage);
return options;
}
private CommandLineOptions ProcessArguments(string[] args)
{
this.commandLineOptions = new CommandLineOptions();
commandLineOptions.Parse(args);
if (commandLineOptions.OutFile != null)
this.writer = new StreamWriter(commandLineOptions.OutFile);
else
this.writer = ConsoleWriter.Out;
if (!commandLineOptions.NoHeader)
WriteCopyright();
if (commandLineOptions.ShowHelp)
writer.Write(commandLineOptions.HelpText);
else if (commandLineOptions.Error)
writer.WriteLine(commandLineOptions.ErrorMessage);
return commandLineOptions;
}
/// <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);
}
