public static void ProcessArguments(string[] args, IArgumentProcessor processor)
{
try
{
foreach (var arg in args)
{
if (arg.StartsWith("--"))
{
processor.OnSwitch(arg.Substring(2));
}
else if (arg.StartsWith("-"))
{
for (var j = 1; j < arg.Length; ++j)
{
processor.OnOption(arg[j]);
}
}
else
{
processor.OnValue(arg);
}
}
processor.ValidateState();
}
catch (ConsoleApplicationException e)
{
Console.Error.WriteLine(e.Message);
processor.PrintHelpMessage(new IndentWriter(Console.Out));
throw e;
}
}
public ArgumentHandler(
IArgumentProcessor idFromExpressionProcessor,
IArgumentProcessor argumentDefinitionsProcessor,
IArgumentProcessor templateArgumentsProcessor)
{
_idFromExpressionProcessor = idFromExpressionProcessor;
_argumentDefinitionsProcessor = argumentDefinitionsProcessor;
_templateArgumentsProcessor = templateArgumentsProcessor;
}
public void CreateArgumentProcessorShouldReturnCLIRunSettingsArgumentProcessorIfCommandIsGiven()
{
var command = "--";
ArgumentProcessorFactory factory = ArgumentProcessorFactory.Create();
IArgumentProcessor result = factory.CreateArgumentProcessor(command, new string[] { "" });
Assert.AreEqual(typeof(CLIRunSettingsArgumentProcessor), result.GetType());
}
public void CreateArgumentProcessorShouldReturnNullIfInvalidCommandIsPassed()
{
var command = "/-";
ArgumentProcessorFactory factory = ArgumentProcessorFactory.Create();
IArgumentProcessor result = factory.CreateArgumentProcessor(command, new string[] { "" });
Assert.IsNull(result);
}
public void CreateArgumentProcessorShouldReturnPlatformArgumentProcessorWhenArgumentIsPlatformInXplat()
{
string argument = "--Platform:x64";
ArgumentProcessorFactory factory = ArgumentProcessorFactory.Create();
IArgumentProcessor result = factory.CreateArgumentProcessor(argument);
Assert.AreEqual(typeof(PlatformArgumentProcessor), result.GetType());
}
public void CreateArgumentProcessorIsTreatingNonArgumentAsSourceEvenItIsStratingFromForwardSlash()
{
string argument = "/foo/foo.dll";
ArgumentProcessorFactory factory = ArgumentProcessorFactory.Create();
IArgumentProcessor result = factory.CreateArgumentProcessor(argument);
Assert.AreEqual(typeof(TestSourceArgumentProcessor), result.GetType());
}
public void CreateArgumentProcessorIsTreatingNonArgumentAsSource()
{
string argument = "--NonArgumet:Dummy";
ArgumentProcessorFactory factory = ArgumentProcessorFactory.Create();
IArgumentProcessor result = factory.CreateArgumentProcessor(argument);
Assert.AreEqual(typeof(TestSourceArgumentProcessor), result.GetType());
}
/// <summary>
/// Executes the argument processor
/// </summary>
/// <param name="processor">Argument processor to execute.</param>
/// <param name="exitCode">Exit status of Argument processor</param>
/// <returns> true if continue execution, false otherwise.</returns>
private bool ExecuteArgumentProcessor(IArgumentProcessor processor, ref int exitCode)
{
var continueExecution = true;
ArgumentProcessorResult result;
try
{
result = processor.Executor.Value.Execute();
}
catch (Exception ex)
{
if (ex is CommandLineException || ex is TestPlatformException || ex is SettingsException || ex is InvalidOperationException)
{
EqtTrace.Error("ExecuteArgumentProcessor: failed to execute argument process: {0}", ex);
this.Output.Error(false, ex.Message);
result = ArgumentProcessorResult.Fail;
// Send inner exception only when its message is different to avoid duplicate.
if (ex is TestPlatformException &&
ex.InnerException != null &&
!string.Equals(ex.InnerException.Message, ex.Message, StringComparison.CurrentCultureIgnoreCase))
{
this.Output.Error(false, ex.InnerException.Message);
}
}
else
{
// Let it throw - User must see crash and report it with stack trace!
// No need for recoverability as user will start a new vstest.console anwyay
throw;
}
}
Debug.Assert(
result >= ArgumentProcessorResult.Success && result <= ArgumentProcessorResult.Abort,
"Invalid argument processor result.");
if (result == ArgumentProcessorResult.Fail)
{
exitCode = 1;
}
if (result == ArgumentProcessorResult.Abort)
{
continueExecution = false;
}
return(continueExecution);
}
public LinkFactory(
ILinkBuilderFactory linkBuilderFactory,
IAuthorizationProvider authorizationProvider,
IArgumentProcessor idFromExpressionProcessor,
IArgumentProcessor argumentsDefinitionsProcessor,
IArgumentProcessor templateArgumentsProcessor,
params IRegistrationLinkHandler[] handlers)
{
_linkBuilderFactory = linkBuilderFactory;
_authorizationProvider = authorizationProvider;
_idFromExpressionProcessor = idFromExpressionProcessor;
_argumentsDefinitionsProcessor = argumentsDefinitionsProcessor;
_templateArgumentsProcessor = templateArgumentsProcessor;
_handlerChain = (handlers.Length > 0 ? handlers : DefaultHandlers).CreateChain();
}
/// <summary>
/// Decorates a lazy argument processor so that the real processor is initialized when the lazy value is obtained.
/// </summary>
/// <param name="processor">The lazy processor.</param>
/// <param name="initArg">The argument with which the real processor should be initialized.</param>
/// <returns>The decorated lazy processor.</returns>
private static IArgumentProcessor WrapLazyProcessorToInitializeOnInstantiation(
IArgumentProcessor processor,
string initArg = null)
{
var processorExecutor = processor.Executor;
var lazyArgumentProcessor = new Lazy <IArgumentExecutor>(() =>
{
IArgumentExecutor instance = null;
try
{
instance = processorExecutor.Value;
}
catch (Exception e)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("ArgumentProcessorFactory.WrapLazyProcessorToInitializeOnInstantiation: Exception creating argument processor: {0}", e);
}
throw;
}
if (instance != null)
{
try
{
instance.Initialize(initArg);
}
catch (Exception e)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("ArgumentProcessorFactory.WrapLazyProcessorToInitializeOnInstantiation: Exception initializing argument processor: {0}", e);
}
throw;
}
}
return(instance);
}, System.Threading.LazyThreadSafetyMode.PublicationOnly);
processor.Executor = lazyArgumentProcessor;
return(processor);
}
/// <summary>
/// Executes the argument processor
/// </summary>
/// <param name="processor">Argument processor to execute.</param>
/// <param name="exitCode">Exit status of Argument processor</param>
/// <returns> true if continue execution, false otherwise.</returns>
private bool ExecuteArgumentProcessor(IArgumentProcessor processor, ref int exitCode)
{
var continueExecution = true;
ArgumentProcessorResult result;
try
{
result = processor.Executor.Value.Execute();
}
catch (Exception ex)
{
if (ex is CommandLineException || ex is TestPlatformException)
{
EqtTrace.Error("ExecuteArgumentProcessor: failed to execute argument process: {0}", ex);
this.Output.Error(ex.Message);
result = ArgumentProcessorResult.Fail;
}
else
{
// Let it throw - User must see crash and report it with stack trace!
// No need for recoverability as user will start a new vstest.console anwyay
throw;
}
}
Debug.Assert(
result >= ArgumentProcessorResult.Success && result <= ArgumentProcessorResult.Abort,
"Invalid argument processor result.");
if (result == ArgumentProcessorResult.Fail)
{
exitCode = 1;
}
if (result == ArgumentProcessorResult.Abort)
{
continueExecution = false;
}
return(continueExecution);
}
/// <summary>
/// Lookup the help description for the argument processor.
/// </summary>
/// <param name="argumentProcessor">The argument processor for which to discover any help content</param>
/// <returns>The formatted string containing the help description if found null otherwise</returns>
private string LookupHelpDescription(IArgumentProcessor argumentProcessor)
{
string result = null;
if (argumentProcessor.Metadata.Value.HelpContentResourceName != null)
{
try
{
result = string.Format(
CultureInfo.CurrentUICulture,
argumentProcessor.Metadata.Value.HelpContentResourceName);
//ResourceHelper.GetString(argumentProcessor.Metadata.HelpContentResourceName, assembly, CultureInfo.CurrentUICulture);
}
catch (Exception e)
{
Output.Warning(false, e.Message);
}
}
return(result);
}
public ArgumentProcessorResult Execute()
{
// Output the stock output text
OutputSection(CommandLineResources.HelpUsageText);
OutputSection(CommandLineResources.HelpDescriptionText);
OutputSection(CommandLineResources.HelpArgumentsText);
var argumentProcessorFactory = ArgumentProcessorFactory.Create();
List <IArgumentProcessor> processors = new List <IArgumentProcessor>();
processors.AddRange(argumentProcessorFactory.AllArgumentProcessors);
processors.Sort((p1, p2) => Comparer <HelpContentPriority> .Default.Compare(p1.Metadata.Value.HelpPriority, p2.Metadata.Value.HelpPriority));
// Output the help description for RunTestsArgumentProcessor
IArgumentProcessor runTestsArgumentProcessor = processors.Find(p1 => p1.GetType() == typeof(RunTestsArgumentProcessor));
processors.Remove(runTestsArgumentProcessor);
var helpDescription = LookupHelpDescription(runTestsArgumentProcessor);
if (helpDescription != null)
{
OutputSection(helpDescription);
}
// Output the help description for each available argument processor
OutputSection(CommandLineResources.HelpOptionsText);
foreach (var argumentProcessor in processors)
{
helpDescription = LookupHelpDescription(argumentProcessor);
if (helpDescription != null)
{
OutputSection(helpDescription);
}
}
OutputSection(CommandLineResources.Examples);
// When Help has finished abort any subsequent argument processor operations
return(ArgumentProcessorResult.Abort);
}
public OldFormatLineProcessor(IArgumentProcessor argumentProcessor = null)
{
this.argumentProcessor = argumentProcessor ?? new ArgumentProcessor();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="argumentExceptionProcessor">Instance of IArgumentProcessor</param>
/// <param name="cloneProcessor">Instance of ICloneProcessor</param>
public Application(IArgumentProcessor argumentExceptionProcessor, ICloneProcessor cloneProcessor)
{
_argumentExceptionProcessor = argumentExceptionProcessor;
_cloneProcessor = cloneProcessor;
}
public WithDollarLineProcessor(IArgumentProcessor argumentProcessor = null)
{
this.argumentProcessor = argumentProcessor ?? new ArgumentProcessor();
}
