public void Should_be_able_to_retrieve_args_by_position() { var args = new[] { "one", "two", "three" }; var arguments = argParser.Parse(args); var one = ""; var two = ""; var three = ""; var threeFailed = false; arguments.At(0, a => one = a.Value).FailWith(() => Assert.True(false, "should succeed")); arguments.At(1, a => two = a.Value).FailWith(() => Assert.True(false, "should succeed")); arguments.At(2, a => three = a.Value).FailWith(() => Assert.True(false, "should succeed")); arguments.At(3, a => Assert.True(false, "Should not be an arg at 3")).FailWith(() => threeFailed = true); one.ShouldEqual(args[0]); two.ShouldEqual(args[1]); three.ShouldEqual(args[2]); threeFailed.ShouldBeTrue(); }
public void CanParseParameterWithAbsolutePath() { var parameter = parser.Parse(new[] { "-path:c:\\temp\\someFile.txt" }) .Cast <NamedCommandLineParameter>().Single(); Assert.AreEqual("path", parameter.Name); Assert.AreEqual("c:\\temp\\someFile.txt", parameter.Value); }
/// <summary> /// Carga la lista de email en la lista y prepara el envío /// </summary> private void LoadMails() { if (Properties.Settings.Default.MailList != null) { int i = 0; foreach (string mail in Properties.Settings.Default.MailList) { ArgParser argumentos = new ArgParser(); Sender sender = new Sender(); if (argumentos.Parse(ref sender, mail.Substring(mail.IndexOf(';') >= 0 ? mail.IndexOf(';') : 0)) == 0) { ListViewItem itm = new ListViewItem(); itm.Text = (lst.Items.Count + 1).ToString(); itm.SubItems.Add(mail.Substring(0, 1) == "0"? "ENVIADO" : "BANDEJA SALIDA"); itm.SubItems.Add(sender.Attachment.Length > 0 ? "🔗" : "-"); itm.SubItems.Add(sender.To); itm.SubItems.Add("N/A"); itm.Tag = sender; sender.MessageID = i; sender.Sent = mail.Substring(0, 1) == "0" ? true : false; lst.Items.Add(itm); if (!sender.Sent) { state.AddMessage(sender); } i++; } } } }
static void Main(string[] args) { Console.WriteLine("------------------------------------------------------------------------"); Console.WriteLine("Utility to rename, set creation date or delete files"); Console.WriteLine("------------------------------------------------------------------------"); try { var(tasks, options) = ArgParser.Parse(args, new TaskValidator()); if (tasks is null || options is null) { PrintUsage(); return; } var processor = new TaskProcessor(options, new FileProcessorFactory()); processor.Execute(tasks); } catch (Exception ex) { ConsoleLog.WriteError(ex.Message); } Console.WriteLine(); Console.WriteLine("------------------------------------------------------------------------"); Console.WriteLine(">> Done. Press ENTER to quit. "); Console.ReadLine(); }
public override void SampleCall(string[] args) { #region Parse Arguments ArgParser cmdLineParser = new ArgParser(); if (!cmdLineParser.Parse(args)) { // Parse failed. PrintUsage(INVALID_ARGUMENTS_ERROR); return; } #endregion #region Initialize Properties ContextProperties contextProps = new ContextProperties(); SessionProperties sessionProps = SampleUtils.NewSessionPropertiesFromConfig(cmdLineParser.Config); #endregion InitContext(cmdLineParser.LogLevel); using (Requestor requestor = new Requestor(contextProps, sessionProps)) using (Responder responder = new Responder(contextProps, sessionProps)) { requestor.SendTo(responder.ReceivingOn); requestor.Commit(); Log.Start("Waiting for message"); Log.AssertTrue(requestor.WaitForMessage(15000), "Timeout while waiting for message"); } }
public void DeleteBySize_NoSourceDir() { string[] bySizeArgs = new string[] { "ds", "-z:5", "-r", "-f:*Rot*" }; var(tasks, options) = ArgParser.Parse(bySizeArgs, new TaskValidator()); Assert.AreEqual(1, tasks.Count); Assert.AreEqual(3, options.Count); }
public void DeleteBySize_Test() { string[] bySizeArgs = new string[] { "ds", @"-i:e:\@@@test", "-z:5", "-r", "-f:*Rot*" }; var(tasks, options) = ArgParser.Parse(bySizeArgs, new TaskValidator()); Assert.AreEqual(1, tasks.Count); Assert.AreEqual(4, options.Count); }
/// <summary> /// The DotBook entry point. /// </summary> /// <param name="args">Command line args</param> public static void Main(string[] args) { var p = new ArgParser(); var arg = new ApplicationArguments(); p.UseOwnOptionPrefix("-", "--"); p.Setup(v => arg.OutputDirectory = string.Join(" ", v)) .As('o', "output") .SetDefault("docs") .WithDescription("Output directory for the generated documentation. " + "If not specified, defaults to 'docs'."); p.Setup(v => arg.InputDirectory = string.Join(" ", v)) .As('s', "src") .WithDescription("Directory for C# code search"); p.Setup(v => arg.Visibility = v.ToEnum <Modifier>()) .As('v', "visibility") .SetDefault("public") .WithDescription("Include types and members with the specified " + "visibilities. Defaults to 'public'."); p.Setup(v => bool.Parse(v.FirstOrDefault() ?? "true")) .As('h', "use-hash") .SetDefault("false") .WithDescription("Use hashing for documentation filenames to " + "allow deep hierarchies. " + "If false, uses escaped type/member name. " + "Defaults to 'false'."); p.Setup(v => arg.Format = v.ToEnum <FileFormat>().First()) .As('f', "format") .SetDefault("Markdown") .WithDescription("Sets the output format. Default is Markdown. " + "Available formats: Markdown, Html"); p.SetupHelp("?", "help") .Callback(v => { Console.WriteLine(string.Join("\n", p.GetHelp())); Environment.Exit(0); }); p.Parse(args); try { Info("Using the following parameters:"); Log($"{arg}"); Run(arg); } catch (PathTooLongException pex) { Fatal("Hierarchy is too deep to use type/member names " + "as filenames. Try using the --use-hash flag." + $"{pex}"); } }
public void ShouldValidateBasicParse() { var stu = new ArgParser(); var args = "-l -p 8080 -d /usr/logs".Split(" "); stu.Parse(args, new Schema()); Assert.Equal(stu.FlagValue("l"), false.ToString()); }
public void IndexIsOneBased() { var parameters = parser.Parse(new[] { "firstArg", "secondArg" }) .Cast <PositionalCommandLineParameter>().ToList(); Assert.AreEqual(1, parameters[0].Index); Assert.AreEqual(2, parameters[1].Index); }
public void MultiplesNotAllowed() { int i1 = 0, i2 = 0; var ap = new ArgParser( new Int32Arg("-n", "<int> sets the integer") { Command = (n) => { i1 = n; i2 = n * n; } }); var extras = ap.Parse(new string[] { "-n", "5", "-n", "6" }); }
public void ExecuteTasks_Test() { string[] bySizeArgs = new string[] { "ds", @"-i:e:\@@@test", "-z:5", "-r", "-f:*Rot*", "-force" }; var(tasks, options) = ArgParser.Parse(bySizeArgs, new TaskValidator()); Assert.AreEqual(1, tasks.Count); Assert.AreEqual(4, options.Count); var factory = new MockFileProcessorFactory(); var processor = factory.Create(tasks, string.Empty, 0, false, true, true); processor.ApplyTasks(); }
public void BasicIntArg() { int i1 = 0, i2 = 0; var ap = new ArgParser( new Int32Arg("-n", "<int> sets the integer") { Command = (n) => { i1 = n; i2 = n * n; } }); var extras = ap.Parse(new string[] { "-n", "5" }); Assert.IsTrue(extras.Count == 0); Assert.AreEqual(i1, 5); Assert.AreEqual(i2, 25); }
public void MustHaveRequired() { int i1 = 0, i2 = 0; var ap = new ArgParser( new Int32Arg("-n", "<int> sets the integer") { Command = (n) => { i1 = n; i2 = n * n; } }, new StrArg("-f", "a required flag") { Required = true }); var extras = ap.Parse(new string[] { "-n", "5" }); }
public void MultiplesAllowed() { int sum = 0; var ap = new ArgParser( new Int32Arg("-n", "<int> accumulates given numbers") { Command = (n) => { sum += n; }, Default = 100, // make sure it's not applied MultiplesAllowed = true }); var extras = ap.Parse(new string[] { "-n", "5", "-n", "6" }); Assert.IsTrue(extras.Count == 0); Assert.AreEqual(sum, 11); }
public void When_VoxelFlagIsGiven_Expect_VoxelSolution() { string inputStr = Path.Combine("Input_Files", "input.txt"); string outputStr = Path.Combine("Output_Files", "output.txt"); // IO must be either "Input_Files" or "Output_Files". // Expected output for test files. // Paths contain "Nodegraph_Generator.Tests" string relativeInputPath = Path.Combine(OSString, inputStr); string relativeOutputPath = Path.Combine(OSString, outputStr); string[] inputArgs = { relativeInputPath, relativeOutputPath, "-v" }; FilePaths result = ArgParser.Parse(inputArgs); Assert.True(result.voxelSolution); }
public bool Parse(List <string> argv) { int i = ArgParser.Parse(argv, "-fix"); if (i < 0) { return(false); } string modelname = ""; string prefix = ""; string package = ""; string vertxt = ""; FixVersion ver = FixVersion.UniversityReady; while (argv.Count > i) { if (ArgParser.Parse(argv, i, "-package", ref package)) { continue; } if (ArgParser.Parse(argv, i, "-modelname", ref modelname)) { continue; } if (ArgParser.Parse(argv, i, "-prefix", ref prefix)) { continue; } if (ArgParser.Parse(argv, i, "-fixversion", ref vertxt)) { switch (vertxt.Trim().ToLower()) { case "uni1": ver = FixVersion.UniversityReady; break; case "uni2": ver = FixVersion.UniversityReady2; break; } continue; } SimPe.Message.Show(Help()[0]); return(true); } Fix(package, prefix + modelname, ver); return(true); }
public void CatchExtras() { int sum = 0; var ap = new ArgParser( new Int32Arg("-n", "<int> accumulates given numbers") { Command = (n) => { sum += n; }, Default = 100, MultiplesAllowed = true }); var extras = ap.Parse(new string[] { "-n", "5", "what", "-n", "6", "else" }); Assert.IsTrue(extras.Count == 2); Assert.AreEqual(extras[0], "what"); Assert.AreEqual(extras[1], "else"); Assert.AreEqual(sum, 11); }
public bool Parse(List <string> argv) { int i = ArgParser.Parse(argv, "-build"); if (i < 0) { return(false); } Splash.Screen.SetMessage("Building Package..."); string output = ""; string input = ""; while (argv.Count - i > 0 && input.Length == 0 && output.Length == 0) { if (ArgParser.Parse(argv, i, "-desc", ref input)) { continue; } if (ArgParser.Parse(argv, i, "-out", ref output)) { continue; } SimPe.Message.Show(Help()[0]); return(true); } if (input.Length == 0 || output.Length == 0) { SimPe.Message.Show(Help()[0]); return(true); } if (!System.IO.File.Exists(input)) { SimPe.Message.Show(Help()[0]); return(true); } GeneratableFile pkg = GeneratableFile.LoadFromStream(XmlPackageReader.OpenExtractedPackage(null, input)); pkg.Save(output); Splash.Screen.SetMessage(""); return(true); }
static void Main(string[] args) { var parsed = ArgParser.Parse(args); var di = new DirectoryInfo(Path.GetDirectoryName(parsed.Input)); var dlls = di.EnumerateFiles(Path.GetFileName(parsed.Input)); #if PARALLEL Parallel.ForEach(dlls, dll => #else foreach (var dll in dlls) #endif { using (var input = File.OpenRead(dll.FullName)) using (var output = File.OpenWrite(Path.Combine(parsed.Output, dll.Name))) { AutoLogProcessor.AddLoggingToAssembly(input, output, dll.DirectoryName); } }
public virtual Tuple <int, int> GetTestTimesAndInterval(string[] args) { var parsedOK = false; Options = ArgParser.Parse <ArgClass>(args, out parsedOK); // Add wait checking here as this method is definitely called by all derived classes. if (parsedOK && Options.WaitSecondsForAttachDebug > 0) { var waitBegin = DateTime.Now; var waitEnd = waitBegin + TimeSpan.FromSeconds(Options.WaitSecondsForAttachDebug); var currentPID = Process.GetCurrentProcess().Id; Logger.LogWarn($"Will wait {Options.WaitSecondsForAttachDebug} seconds for you to debug this process : please attach PID {currentPID} before {waitEnd}"); Thread.Sleep(Options.WaitSecondsForAttachDebug * 1000); } return(parsedOK ? new Tuple <int, int>(Options.TestTimes, Options.TestIntervalSeconds) : new Tuple <int, int>(-1, 0)); }
public static void Main(string[] args) { // PrintSpecialFolders(); var argParser = new ArgParser(args); if (argParser.Parse()) { var year = argParser.Year; var user = argParser.User; var budget = CreateBudget(year, user); budget.Save(); var month = GetMonth(); var report = DoMonthlyReport(month, year, user); report.Save(); } }
public void When_Correct_ArgumentsIsGiven_Expect_True() { string inputStr = Path.Combine("Input_Files", "input.txt"); string outputStr = Path.Combine("Output_Files", "output.txt"); // IO must be either "Input_Files" or "Output_Files". // Expected output for test files. // Paths contain "Nodegraph_Generator.Tests" string relativeInputPath = Path.Combine(OSString, inputStr); string relativeOutputPath = Path.Combine(OSString, outputStr); string[] inputArgs = { relativeInputPath, relativeOutputPath }; FilePaths result = ArgParser.Parse(inputArgs); string expectedInputPath = Path.Combine("SUM_Nodegraph_Generator", inputStr); string expectedOutputPath = Path.Combine("SUM_Nodegraph_Generator", outputStr); StringAssert.Contains(expectedInputPath, result.inFile); StringAssert.Contains(expectedOutputPath, result.outFile); // When no flag is given it should be voxelSoluton by default. Assert.True(result.voxelSolution); }
public static string MainString(string command) { // Helper that executes an input string command and returns results string[] args = command.Split(); var parsed = ArgParser.Parse(args); if (parsed.ParsedOk == false) { Info.ShowLogo(); Info.ShowUsage(); return($"Error parsing arguments: {command}"); } var commandName = args.Length != 0 ? args[0] : ""; TextWriter realStdOut = Console.Out; TextWriter realStdErr = Console.Error; TextWriter stdOutWriter = new StringWriter(); TextWriter stdErrWriter = new StringWriter(); Console.SetOut(stdOutWriter); Console.SetError(stdErrWriter); MainExecute(commandName, parsed.Arguments); Console.Out.Flush(); Console.Error.Flush(); Console.SetOut(realStdOut); Console.SetError(realStdErr); string output = ""; output += stdOutWriter.ToString(); output += stdErrWriter.ToString(); return(output); }
static void Main(string[] args) { Logger.Info(EnvironmentInfo); var parsedOK = false; var options = ArgParser.Parse <ArgReadWriteKafka>(args, out parsedOK); if (!parsedOK) { return; } var brokers = options.BrokerList.Split(";,".ToCharArray()); var brokersUriList = new List <Uri>(brokers.Select(broker => new Uri(broker))); if (options.IsWrite) { WriteTestData(brokersUriList, options); } else { ReadData(brokersUriList, options); } }
public static void Main(string[] args) { // Parse the command line arguments - Show usage on failure var parsed = ArgParser.Parse(args); if (parsed.ParsedOk == false) { Info.ShowLogo(); Info.ShowUsage(); return; } var commandName = args.Length != 0 ? args[0] : ""; if (parsed.Arguments.ContainsKey("/consoleoutfile")) { // Redirect output to a file specified FileExecute(commandName, parsed.Arguments); } else { MainExecute(commandName, parsed.Arguments); } }
/// <summary> /// Carga un mensaje a la lista desde la línea de comandos /// </summary> /// <param name="args">Argumentos de la línea de comandos</param> public void NuevoMensaje(string[] args) { if (args.Length > 0) { ArgParser argumentos = new ArgParser(args); Sender sender = new Sender(); if (argumentos.Parse(ref sender) == 0) { ListViewItem itm = new ListViewItem(); itm.Text = (lst.Items.Count + 1).ToString(); itm.SubItems.Add("BANDEJA SALIDA"); itm.SubItems.Add(sender.Attachment.Length > 0 ? "🔗" : "-"); itm.SubItems.Add(sender.To); itm.SubItems.Add("N/A"); sender.MessageID = lst.Items.Count; sender.Sent = false; GuardarMail(1, argumentos.RawCompose); itm.Tag = sender; lst.Items.Add(itm); state.AddMessage(sender); } if (argumentos.State == 1 && state.Estado != 1) { IniciarEnvio(); } if (argumentos.State == 2 && state.Estado != 2) { PausarEnvio(); } } }
public static bool IsFunctionCall(string line, out FunctionCallInfo info) { //test (20); //teset(ToDeg(Sin(PI))); //Func(RandX(),Rand(20,50)); //for (int i = 0; i < 20, i++) //if (True) //int x = Rand(0,100); info = null; string[] split = line.Split(new[] { '(' }, 2, StringSplitOptions.RemoveEmptyEntries); //test 20); //teset ToDeg(Sin(PI))); //Func RandX(),Rand(20,50)); //for int i = 0; i < 20, i++) //if True) //int x = Rand 0,100); if (split.Length < 2) { return(false); } split[0] = split[0].TrimEnd(); if (FunctionNames.Fuctions.Contains(split[0]) && !split[1].EndsWith(";")) { throw new ParsingException("Missing semicolon after a function call!", line); } split[1] = split[1].TrimEnd(';', ' '); //test 20) //teset ToDeg(Sin(PI))) //Func RandX(),Rand(20,50)) //for int i = 0; i < 20, i++) //if True) //int x = Rand 0,100) split[1] = split[1].Remove(split[1].Length - 1, 1); //test 20 //teset ToDeg(Sin(PI)) //Func RandX(),Rand(20,50) //for int i = 0; i < 20, i++ //if True //int x = Rand 0,100 if (IsType(split[1].Split()[0], out _)) { return(false); } if (split[0].TrimEnd() == "for" || split[0].TrimEnd() == "if") { return(false); } if (split[0].Contains("=")) { return(false); } FunctionCallInfo i = new FunctionCallInfo(); i.FunctionName = split[0].TrimEnd(); i.Arguments = ArgParser.Parse(split[1].TrimEnd()); info = i; return(true); }
int Execute(string[] args) { try { if (args.Any(HelpArgs.Contains)) { PrintUsage(); return(2); } string requestedTargetFramework; try { ParsedArgs = ArgParser.Parse(args); if (ParsedArgs.TryGetAndRemoveParameterWithoutValue("-x86")) { Force32bit = true; } if (ParsedArgs.TryGetParameterWithoutValue("-internaldiagnostics")) { InternalDiagnostics = true; } if (ParsedArgs.TryGetParameterWithoutValue("-nocolor")) { NoColor = true; } // The extra versions are unadvertised compatibility flags to match 'dotnet' command line switches requestedTargetFramework = ParsedArgs.GetAndRemoveParameterWithValue("-framework") ?? ParsedArgs.GetAndRemoveParameterWithValue("--framework") ?? ParsedArgs.GetAndRemoveParameterWithValue("-f"); Configuration = ParsedArgs.GetAndRemoveParameterWithValue("-configuration") ?? ParsedArgs.GetAndRemoveParameterWithValue("--configuration") ?? ParsedArgs.GetAndRemoveParameterWithValue("-c") ?? "Debug"; FxVersion = ParsedArgs.GetAndRemoveParameterWithValue("-fxversion") ?? ParsedArgs.GetAndRemoveParameterWithValue("--fx-version"); NoBuild = ParsedArgs.GetAndRemoveParameterWithoutValue("-nobuild") || ParsedArgs.GetAndRemoveParameterWithoutValue("--no-build"); // Need to amend the paths for the report output, since we are always running // in the context of the bin folder, not the project folder var currentDirectory = Directory.GetCurrentDirectory(); foreach (var key in OutputFileArgs) { if (ParsedArgs.TryGetSingleValue(key, out var fileName)) { ParsedArgs[key][0] = Path.GetFullPath(Path.Combine(currentDirectory, fileName)); } } } catch (ArgumentException ex) { WriteLineError(ex.Message); return(3); } var testProjects = Directory.EnumerateFiles(Directory.GetCurrentDirectory(), "*.*proj") .Where(f => !f.EndsWith(".xproj")) .ToList(); if (testProjects.Count == 0) { WriteLineError("Could not find any project (*.*proj) file in the current directory."); return(3); } if (testProjects.Count > 1) { WriteLineError($"Multiple project files were found; only a single project file is supported. Found: {string.Join(", ", testProjects.Select(x => Path.GetFileName(x)))}"); return(3); } ThisAssemblyPath = Path.GetDirectoryName(typeof(Program).GetTypeInfo().Assembly.Location); BuildStdProps = $"\"/p:_Xunit_ImportTargetsFile={Path.Combine(ThisAssemblyPath, "import.targets")}\" " + $"/p:Configuration={Configuration}"; var returnValue = 0; var testProject = testProjects[0]; var targetFrameworks = GetTargetFrameworks(testProject); if (targetFrameworks == null) { WriteLineError("Detection failed! Please ensure you're using 'xunit.core' v2.3 beta 2 or later."); return(3); } if (requestedTargetFramework != null) { if (!targetFrameworks.Contains(requestedTargetFramework, StringComparer.OrdinalIgnoreCase)) { WriteLineError($"Unknown target framework '{requestedTargetFramework}'; available frameworks: {string.Join(", ", targetFrameworks.Select(f => $"'{f}'"))}"); return(3); } returnValue = RunTargetFramework(testProject, requestedTargetFramework, amendOutputFileNames: false); } else { foreach (var targetFramework in targetFrameworks) { returnValue = Math.Max(RunTargetFramework(testProject, targetFramework, amendOutputFileNames: targetFrameworks.Length > 1), returnValue); } } return(returnValue); } catch (Exception ex) { WriteLineError(ex.ToString()); return(3); } }
private string[] MapObject(object o, CommandLineArgumentsDefinition effectiveDefinition) { List <string> newCommandLine = new List <string>(); newCommandLine.AddRange(CmdLineArgs); var preParseResult = ArgParser.Parse(effectiveDefinition, newCommandLine.ToArray()); var predictedAction = effectiveDefinition.FindMatchingAction(this.CmdLineArgs[0]); if (predictedAction == null) { PowerLogger.LogLine("Could not determine action: " + this.CmdLineArgs[0] + " - Here are the supported action:"); foreach (var action in effectiveDefinition.Actions) { PowerLogger.LogLine(" " + action.DefaultAlias); } throw new ArgException("TODO - Could not determine action: " + this.CmdLineArgs[0]); } PowerLogger.LogLine("Predicted action is " + predictedAction.DefaultAlias); var argsToInspectForDirectMappingTarget = predictedAction.Arguments.Union(effectiveDefinition.Arguments).ToList(); var directMappingTarget = (from argument in argsToInspectForDirectMappingTarget where argument.Metadata.HasMeta <ArgPipelineTarget>() select argument).SingleOrDefault(); if (directMappingTarget != null) { var revivedValue = o; if (IsCompatible(o, directMappingTarget) == false) { PowerLogger.LogLine("Need to map " + o.GetType().FullName + " to " + directMappingTarget.ArgumentType.FullName); if (TrySimpleConvert(o, directMappingTarget.ArgumentType, out revivedValue)) { // we're good } else if (ArgPipelineObjectMapper.CurrentMapper == null) { throw new InvalidArgDefinitionException("Unable to attempt tp map type " + o.GetType().FullName + " to " + directMappingTarget.ArgumentType.FullName + " because no mapper is registered at ArgPipelineObjectMapperProvider.CurrentMapper"); } else { revivedValue = ArgPipelineObjectMapper.CurrentMapper.MapIncompatibleDirectTargets(directMappingTarget.ArgumentType, o); } } effectiveDefinition.Metadata.Add(new ArgumentOverrideHook(directMappingTarget, revivedValue)); } else { PowerLogger.LogLine("Attempting to shred object: " + o.ToString()); foreach (var argument in predictedAction.Arguments.Union(effectiveDefinition.Arguments)) { bool manualOverride = false; foreach (var explicitKey in preParseResult.ExplicitParameters.Keys) { if (argument.IsMatch(explicitKey)) { manualOverride = true; break; } } if (preParseResult.ImplicitParameters.ContainsKey(argument.Position)) { manualOverride = true; } if (manualOverride) { continue; } var mapper = argument.Metadata.Meta <ArgPipelineExtractor>() ?? new ArgPipelineExtractor(); string mappedKey, mappedValue; if (mapper.TryExtractObjectPropertyIntoCommandLineArgument(o, argument, out mappedKey, out mappedValue)) { newCommandLine.Add(mappedKey); newCommandLine.Add(mappedValue); } } } return(newCommandLine.ToArray()); }