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