public void ParseCmdLineWithAliasTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name", "Billy Bob", "/Age", "25", "/Job", "Stranger", "/HasHair", "false", "/Children", "Billy", "Bob", "Betty" }; var results = parser.Parse(args); var obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual("Billy Bob", obj.Name); Assert.AreEqual(25, obj.Age); Assert.AreEqual("Stranger", obj.Occupation); Assert.AreEqual(false, obj.HasHair); Assert.AreEqual(3, obj.Children.Length); Assert.AreEqual("Billy", obj.Children[0]); Assert.AreEqual("Bob", obj.Children[1]); Assert.AreEqual("Betty", obj.Children[2]); }
private static CmdLineParser ParseArguments(string[] args) { Dictionary <string, string> dict = args.Select(s => s.Split(':')).ToDictionary(s => s[0].Replace("/", ""), s => s[1]); CmdLineParser cmdLineParser = CmdLineParser.DictionaryToObject <CmdLineParser>(dict); return(cmdLineParser); }
public void GetCmdLinePropertiesTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var obj = new TestCmdLineObj(); var props = parser.GetCmdLineProperties(obj); Assert.AreEqual(7, props.Count); var prop = props["Name"]; Assert.IsNotNull(prop); Assert.AreEqual("Name", prop.Name); prop = props["N"]; // Use an abbreviated name. Assert.IsNotNull(prop); Assert.AreEqual("Name", prop.Name); prop = props["age"]; // Use a different case. Assert.IsNotNull(prop); Assert.AreEqual("Age", prop.Name); Assert.IsFalse(prop.ValueSet); prop.Value = 23; Assert.IsTrue(prop.ValueSet); Assert.AreEqual(23, obj.Age); }
/// <summary> /// Initializes a new instance of the Options class with the specified command /// line arguments. /// </summary> /// <param name="args">The arguments passed on the command line.</param> public Options(string[] args) { // Initialize the options _StartDateOption = new DateOption("s", "startdate"); _BuildOption = new StringOption("b", "build", "Fixed"); _PinOption = new StringOption("p", "pin", "0.0.0.0"); _RevisionOption = new StringOption("r", "revision", "Automatic"); _InputFile = new StringOption("i", "inputfile"); _OutputFile = new StringOption("o", "outputfile"); _Input = new StringOption("in", "input"); _VersionOption = new StringOption("v", "version"); // Create a new command line parser and add our options CmdLineParser parser = new CmdLineParser(); parser.AddOption(_StartDateOption); parser.AddOption(_BuildOption); parser.AddOption(_PinOption); parser.AddOption(_RevisionOption); parser.AddOption(_InputFile); parser.AddOption(_OutputFile); parser.AddOption(_VersionOption); // Try to parse our options try { parser.Parse(args); ValidatePinOption(); } catch (Exception) { throw; } }
public void ParseCmdLineAssignmentOpTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name=Billy Bob", "/Age=25", "/Occupation=Stranger", "/HasHair=false", "/Children=Billy,Bob,Betty", "/PersonType=Father" }; parser.Options.AssignmentDelimiter = "="; // Need to set ArraySeparator as well. Assert.That.Throws <InvalidOperationException>(() => { parser.Parse(args); }); parser.Options.ArraySeparator = ","; var results = parser.Parse(args); var obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual("Billy Bob", obj.Name); Assert.AreEqual(25, obj.Age); Assert.AreEqual("Stranger", obj.Occupation); Assert.AreEqual(false, obj.HasHair); Assert.AreEqual(3, obj.Children.Length); Assert.AreEqual("Billy", obj.Children[0]); Assert.AreEqual("Bob", obj.Children[1]); Assert.AreEqual("Betty", obj.Children[2]); Assert.AreEqual(PersonType.Father, obj.PersonType); }
public MainForm(string[] args) { InitializeComponent(); PostLoad(); Cmd = new CmdLineParser(args); }
public void ShouldParseMultipleUndefinedOptionIfAllowed() { var builder = new CmdLineInputDefinitionBuilder(); var settings = new CmdLineSettings { UndefinedOptionsPolicy = UndefinedOptionsPolicy.AllowMultipleInstances }; var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse("-name:value1.1;value1.2", "-name:value2.1;value2.2"); input.UndefinedOptions.GetAll("name").ShouldBe(new[] { new[] { "value1.1", "value1.2" }, new[] { "value2.1", "value2.2" } }); }
private void InitParserIfNecessary() { if (_commandParser == null) { _commandParser = new CmdLineParser(new PrinterTextWriter(Printer)); _allCommandTypes = GetAllCommandTypes(); } }
public void ShouldParseMissingOptionalArg() { var builder = new CmdLineInputDefinitionBuilder(); builder.Arg("name").IsOptional(); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); parser.Parse(new string[0]); }
public void ShouldParseFlagOption() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse(new[] { "-name" }); input.Options.Contains("name").ShouldBe(true); }
public void ShouldParseArg() { var builder = new CmdLineInputDefinitionBuilder(); builder.Arg("name"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse(new[] { "value" }); input.Args.GetSingle("name").ShouldBe("value"); }
public void ShouldParseOptionsWithSeparatedFormat() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name").Value("value"); var settings = new CmdLineSettings { OptionValueFormat = OptionValueFormat.Separated }; var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse("-name", "foo"); input.Options.GetSingle("name").GetSingle("value").ShouldBe("foo"); }
public void ShouldParseOptionWithParamsValue() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name") .Value("value", x => x.IsParams()); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse("-name:foo;bar"); input.Options.GetSingle("name").GetAll("value").ShouldBe(new[] { "foo", "bar" }); }
static void Main(string[] args) { args = new string[] { @"/key", @"/s", @"StringValue", @"/i", @"1488", @"/d", @"14,88" }; CmdLineParser parser = new CmdLineParser(); try { Console.WriteLine("Params:"); Console.WriteLine("Params usage:\n\b{0}", parser.GetUsageText<TestOptionClass>()); Console.WriteLine(); parser.ParseCmdLine(args); TestOptionClass options = parser.GetCmdLineOptions<TestOptionClass>(); Console.WriteLine("Test Class Object:"); Console.WriteLine("Required Key param: {0}", options.KeyParam); Console.WriteLine("Not Required Key param: {0}", options.NotRequiredKeyParam); Console.WriteLine("Required String param: {0}", options.StringParam); Console.WriteLine("Required Int param: {0}", options.IntParam); Console.WriteLine("Not Required Double param: {0}", options.DoubleParam); } catch(ParseCmdLineException parseEx) { switch(parseEx.ParseError) { case EParseError.E_KEYEXISTS: break; case EParseError.E_KEYNOTFOUND: break; } Console.WriteLine("Parse cmd line exception!"); } catch(OptionParserException optionEx) { switch(optionEx.ErrorCode) { case EOptionParserError.E_INVALID_CONVERT_TYPE: break; case EOptionParserError.E_INVALID_KEY_PROPERTY_TYPE: break; case EOptionParserError.E_REQUIRED_OPTION_NOT_EXIST: break; } Console.WriteLine("Option class creation exception!"); } }
public void GenerateUsageTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var results = parser.Parse(new string[] { }); results.ApplicationFileName = "test.exe"; var generator = new HelpGenerator(results); var usage = generator.GetUsage(); Assert.AreEqual("test.exe <Name|String> [/Type <Father|Mother|Child>]", usage); }
public void BasicInstanceWithDefaultOptionsTest() { // Make sure the defaults aren't changed. The defaults are used // for standard Windows console argument parsing. var parser = new CmdLineParser <TestCmdLineObj>(); Assert.IsNotNull(parser.Options); Assert.AreEqual("/", parser.Options.ArgumentPrefix); Assert.AreEqual(null, parser.Options.AssignmentDelimiter); Assert.AreEqual(StringComparison.OrdinalIgnoreCase, parser.Options.Comparer); Assert.AreEqual(null, parser.Options.ArraySeparator); }
private void Run() { // The NO_CONSOLE environment variable requests that console modifications such as the following one // are not performed. This is necessary in no-console environments such as Azure App Service. if (Environment.GetEnvironmentVariable("NO_CONSOLE") == null) { const int ConsoleBufferSize = 4096; Console.SetIn(new StreamReader( Console.OpenStandardInput(bufferSize: ConsoleBufferSize), Console.InputEncoding, false, ConsoleBufferSize) ); } Console.BackgroundColor = ConsoleColor.Black; _context.Printer = new ConsolePrinter(); _parser = new CmdLineParser(new PrinterTextWriter(_context.Printer)); ParseCommandLineArguments(); _context.DisplayDiagnosticInformation = _options.DisplayDiagnosticInformation; if (!String.IsNullOrEmpty(_options.DumpFile)) { _target = new AnalysisTarget(_options.DumpFile, _context, _options.ClrVersion); Console.Title = "msos - " + _options.DumpFile; } else if (!String.IsNullOrEmpty(_options.SummaryDumpFile)) { DisplayShortSummary(); return; // Do not proceed to the main loop } else if (!String.IsNullOrEmpty(_options.ProcessName)) { AttachToProcessByName(); } else if (_options.ProcessId != 0) { _target = new AnalysisTarget(_options.ProcessId, _context, _options.ClrVersion); Console.Title = "msos - attached to pid " + _options.ProcessId; } else if (!String.IsNullOrEmpty(_options.TriagePattern)) { RunTriage(); return; // Do not proceed to the main loop } else { PrintUsage(); Bail("One of the -z, --pid, --pn, or --triage options must be specified."); } RunMainLoop(); }
public void ShouldParseMultipleInstancesOfAllowMultipleOption() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name") .AllowMultiple() .Value("value"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse("-name:foo", "-name:bar"); var options = input.Options.GetAll("name"); options.Length.ShouldBe(2); options[0].GetSingle("value").ShouldBe("foo"); options[1].GetSingle("value").ShouldBe("bar"); }
public void ParseCmdLineIntValidationTest() { //https://github.com/BizArk/BizArk3/issues/7 var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name", "Billy Bob" }; var results = parser.Parse(args); Assert.AreEqual(1, results.Errors.Length); Assert.AreEqual("Age is required.", results.Errors[0]); }
public void ParseCmdLineParseErrorTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Age", "XXX", "/ChildrenAges", "1", "XXX", "3" }; var results = parser.Parse(args); Assert.AreEqual(3, results.Errors.Length); Assert.AreEqual("Unable to set Age. Value <XXX> is not valid.", results.Errors[0]); Assert.AreEqual("Unable to set ChildrenAges. Invalid value.", results.Errors[1]); Assert.AreEqual("Name is required.", results.Errors[2]); }
public void ParseCmdLineWithArrayTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name", "Billy Bob", "/Age", "25", "/Occupation", "Stranger", "/HasHair", "false", "/Children", "Billy,Bob,Betty", "/PersonType", "Father" }; parser.Options.ArraySeparator = ","; var results = parser.Parse(args); var obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual("Billy Bob", obj.Name); Assert.AreEqual(25, obj.Age); Assert.AreEqual("Stranger", obj.Occupation); Assert.AreEqual(false, obj.HasHair); Assert.AreEqual(3, obj.Children.Length); Assert.AreEqual("Billy", obj.Children[0]); Assert.AreEqual("Bob", obj.Children[1]); Assert.AreEqual("Betty", obj.Children[2]); Assert.AreEqual(PersonType.Father, obj.PersonType); args = new string[] { "/Name", "Billy Bob", "/Age", "25", "/Occupation", "Stranger", "/HasHair", "false", "/Children", @"Billy\~Bob\~Betty", "/PersonType", "Father" }; parser.Options.ArraySeparator = @"\~"; // Use a sequence that might effect the regex. results = parser.Parse(args); obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual(3, obj.Children.Length); Assert.AreEqual("Billy", obj.Children[0]); Assert.AreEqual("Bob", obj.Children[1]); Assert.AreEqual("Betty", obj.Children[2]); }
private void button1_Click(object sender, EventArgs e) { if (textBox1.Text == string.Empty) { } else { CmdLineParser cmd = new CmdLineParser(textBox1.Text); var results = cmd.commands; foreach (var item in results) { textBox2.AppendText(item.ToString() + "\n"); } foreach (var item in results) { if (item.ToString().IndexOf("t=") == 0) { String t = String.Empty; t = item.ToString().Substring(2); textBox3.AppendText(String.Format("-t= defined as {0}\n", t)); } if (item.ToString().IndexOf("fin=") == 0) { String t = String.Empty; t = item.ToString().Substring(4); textBox3.AppendText(String.Format("-fin= defined as {0}\n", t)); } if (item.ToString().Contains("al")) { textBox3.AppendText("-al defined\n"); } if (item.ToString().Contains("b")) { textBox3.AppendText("-b defined\n"); } if (item.ToString().Contains("type")) { textBox3.AppendText("-type defined\n"); } if (item.ToString().Contains("car")) { textBox3.AppendText("-car defined\n"); } } } }
public void ParseCmdLineValidationTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Age", "25", "/Job", "A really long invalid name", "/HasHair", "false", "/Children", "Billy", "Bob", "Betty" }; var results = parser.Parse(args); Assert.AreEqual(2, results.Errors.Length); Assert.AreEqual("Name is required.", results.Errors[0]); Assert.AreEqual("Job name too long.", results.Errors[1]); }
public void TransformAssignedArgsTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name=Billy Bob", "/Children=Billy,Bob,Betty" }; parser.Options.AssignmentDelimiter = "="; var newArgs = parser.TransformAssignedArgs(args).ToArray(); Assert.AreEqual(4, newArgs.Length); Assert.AreEqual("/Name", newArgs[0]); Assert.AreEqual("Billy Bob", newArgs[1]); Assert.AreEqual("/Children", newArgs[2]); Assert.AreEqual("Billy,Bob,Betty", newArgs[3]); }
private static IExpression parseCmdLineArgs(String cmdLineArgs) { try { Dictionary <String, String> args = CmdLineParser.parse(cmdLineArgs); Dictionary <TextValue, IValue> valueArgs = new Dictionary <TextValue, IValue>(); foreach (String key in args.Keys) { valueArgs[new TextValue(key)] = new TextValue(args[key]); } DictValue dict = new DictValue(TextType.Instance, false, valueArgs); return(new ValueExpression(argsType, dict)); } catch (Exception) { // TODO return(new DictLiteral(false)); } }
private static void StartWebServer(CmdLineParser cmdParser) { WebServer ws = null; IL298NMotorController iL298NMotorController = new L298NMotorController(); IUltraSonicDistanceSensor ultraSonicDistanceSensor = new UltraSonicDistanceSensor(); if (cmdParser != null) { ws = new WebServer(string.Format("http://{0}:{1}/", cmdParser.HostIp, cmdParser.HostPort), iL298NMotorController, ultraSonicDistanceSensor); } ws.Run(); Console.WriteLine("A simple webserver. Press a key to quit."); Console.ReadKey(); ws.Stop(); Console.WriteLine("Stopped gracefully. Press a key to quit."); Console.ReadKey(); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); if (e.Args.Length > 0) { try { var parser = new CmdLineParser { ThrowInvalidOptionsException = false }; var pathArgument = parser.AddStringParameter("/path", "Directory", false); pathArgument.AddAlias("pATH"); pathArgument.AddAlias("-path"); pathArgument.AddAlias("-dir"); var subDirs = parser.AddBoolSwitch("s", "Including subdirs"); var noWindow = parser.AddBoolSwitch("nowindow", "No window is shown"); parser.AddHelpOption(); //var boolArgument = parser.AddBoolSwitch("-TestBool", "", true); parser.Parse(e.Args); System.Diagnostics.Debug.WriteLine(pathArgument.Value); } catch (Exception ex) { System.Diagnostics.Debug.WriteLine(ex.Message); //throw; } } else { new MainWindow().ShowDialog(); } Shutdown(); }
private void Run() { const int ConsoleBufferSize = 4096; Console.SetIn(new StreamReader( Console.OpenStandardInput(bufferSize: ConsoleBufferSize), Console.InputEncoding, false, ConsoleBufferSize) ); Console.BackgroundColor = ConsoleColor.Black; _context.Printer = new ConsolePrinter(); _parser = new CmdLineParser(new PrinterTextWriter(_context.Printer)); ParseCommandLineArguments(); if (!String.IsNullOrEmpty(_options.DumpFile)) { _target = new AnalysisTarget(_options.DumpFile, _context, _options.ClrVersion); Console.Title = "msos - " + _options.DumpFile; } else if (!String.IsNullOrEmpty(_options.ProcessName)) { AttachToProcessByName(); } else if (_options.ProcessId != 0) { _target = new AnalysisTarget(_options.ProcessId, _context, _options.ClrVersion); Console.Title = "msos - attached to pid " + _options.ProcessId; } else if (!String.IsNullOrEmpty(_options.TriagePattern)) { RunTriage(); return; // Do not proceed to the main loop } else { PrintUsage(); Bail("One of the -z, --pid, --pn, or --triage options must be specified."); } RunMainLoop(); }
static int Main(String[] args) { // Process rsp files // FIXME: This doesn't work with wasm /* * var new_args = new List<string> (); * foreach (var arg in args) { * if (arg [0] == '@') { * foreach (var line in File.ReadAllLines ("/" + arg.Substring (1))) * new_args.Add (line); * } else { * new_args.Add (arg); * } * } */ var cmdline = new CmdLineParser(args); testRunner = new WasmRunner(cmdline.Project); return(testRunner.Run()); }
public void ParseStandardCmdLineTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var args = new string[] { "/Name", "Billy Bob", "/Age", "25", "/Occupation", "Stranger", "/HasHair", "false", "/Children", "Billy", "Bob", "Betty", "/PersonType", "Father" }; var results = parser.Parse(args); var obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual("Billy Bob", obj.Name); Assert.AreEqual(25, obj.Age); Assert.AreEqual("Stranger", obj.Occupation); Assert.AreEqual(false, obj.HasHair); Assert.AreEqual(3, obj.Children.Length); Assert.AreEqual("Billy", obj.Children[0]); Assert.AreEqual("Bob", obj.Children[1]); Assert.AreEqual("Betty", obj.Children[2]); Assert.AreEqual(PersonType.Father, obj.PersonType); args = new string[] { "/HasHair-", // Use a negation flag. }; results = parser.Parse(args); obj = results.Args; Assert.IsNotNull(obj); Assert.AreEqual(false, obj.HasHair); Assert.IsTrue(results.Properties["HasHair"].ValueSet); }
public void GenerateExitCodesTest() { // No exit codes have been defined. var parser = new CmdLineParser <TestCmdLineObj>(); var results = parser.Parse(new string[] { }); parser.Options.ExitCodes = null; var generator = new HelpGenerator(results); var help = generator.GetExitCodesDisplay(); Assert.AreEqual("", help); // Verify the parser can find the ExitCodes enum and InvalidArgs value. parser = new CmdLineParser <TestCmdLineObj>(); results = parser.Parse(new string[] { }); generator = new HelpGenerator(results); help = generator.GetExitCodesDisplay(); Assert.AreEqual(" 0 = Success!!!\r\n1234 = Failed :'(\r\n", help); Assert.AreEqual((int)ExitCodes.InvalidArgs, parser.Options.InvalidArgsExitCode); Assert.IsNull(parser.Options.FatalErrorExitCode); }
public static void Main(string[] args) { InitializeDefaults(); //Parse Command Line Arguments if (CmdLineParser.Parse(args)) { Console.WriteLine(" --> Error parsing command line - quiting."); Environment.Exit(1); } // Process Input File if (!ProcessInputFile.ParseFile()) { Console.WriteLine(" --> Error parsing input file - quiting."); Environment.Exit(2); } // Create and Initialize RNG byte[] byteArray = new byte[1024]; using (var provider = new RNGCryptoServiceProvider()) { provider.GetBytes(byteArray); } StaticRng.Rng = new Gjrand(ref byteArray); Complex[] values = new Complex[4]; values[0] = new Complex(1.1, 1.1); values[1] = new Complex(2.1, 2.1); values[2] = new Complex(-3.3, -2.2); values[3] = new Complex(4.4, -1.1); Combiner c = CombinerFactory.Create(); var r = c.Evaluate(ref values); Console.WriteLine($"{r}"); }
public void GeneratePropHelpTest() { var parser = new CmdLineParser <TestCmdLineObj>(); var results = parser.Parse(new string[] { }); var generator = new HelpGenerator(results); var help = generator.GetPropertyHelp(results.Properties["Name"]); Assert.That.Contains("/Name <String> REQUIRED", help); Assert.That.Contains("\tTEST DESC", help); // Type doesn't have a description, but the flag is set to show it. help = generator.GetPropertyHelp(results.Properties["Type"]); Assert.That.Contains("/PersonType (/Type) <Father|Mother|Child>", help); Assert.That.Contains("\tDefault: Father", help); help = generator.GetPropertyHelp(results.Properties["Children"]); Assert.That.Contains("/Children", help); Assert.That.Contains("\tDefault: [\"One\", \"Two\", \"Three\"]", help); help = generator.GetPropertyHelp(results.Properties["Secret"]); Assert.That.Contains("/Secret", help); Assert.IsFalse(help.Contains("Shhh!")); }
public void ShouldThrowIfMultipleUndefinedOptionsAreProvidedButNotAllowed() { var builder = new CmdLineInputDefinitionBuilder(); var settings = new CmdLineSettings { UndefinedOptionsPolicy = UndefinedOptionsPolicy.AllowSingleInstance }; var parser = new CmdLineParser(builder.Definition, settings); Should.Throw<ParserException>(() => parser.Parse("-name", "-name")).Message.ShouldBe("Option 'name' is provided more than once."); var input = parser.Parse("-name:value1;value2"); input.UndefinedOptions.GetSingle("name").ShouldBe(new[] { "value1", "value2" }); }
public void ShouldThrowIfRequiredArgIsntProvided() { var builder = new CmdLineInputDefinitionBuilder(); builder.Arg("name"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); Should.Throw<Exception>(() => parser.Parse(new string[0])); }
public void ShouldThrowIfRequiredOptionValueIsntProvided() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name").IsRequired().Value("value"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); Should.Throw<ParserException>(() => parser.Parse("-name")); }
public void TearDown() { CmdLineParser.Dispose(); }
static void Main(string[] args) { // try { CmdLineParser cmdLineParser = new CmdLineParser("FSMCompiler v1.0"); cmdLineParser.Add(new ArgumentDefinition("source", 1, "Archivo de entrada.", true)); cmdLineParser.Add(new OptionDefinition("G", "Generador.")); cmdLineParser.Add(new OptionDefinition("H", "Ayuda.")); cmdLineParser.Add(new OptionDefinition("P", "Parametro especifico del generador.")); if (args.Length == 0) { Console.WriteLine(cmdLineParser.HelpText); Console.ReadKey(true); } else { string generatorName = "C"; string sourceFileName = ""; GeneratorParameters generatorParameters = new GeneratorParameters(); cmdLineParser.Parse(args); foreach (OptionInfo optionInfo in cmdLineParser.Options) { switch (optionInfo.Name) { case "G": generatorName = optionInfo.Value; break; case "P": generatorParameters.Add(optionInfo.Value); break; } } foreach (ArgumentInfo argumentInfo in cmdLineParser.Arguments) { switch (argumentInfo.Name) { case "source": sourceFileName = argumentInfo.Value; break; } } Console.WriteLine(); Console.WriteLine("FsmCompiler v1.1"); Console.WriteLine("-------------------------------------------------------------"); Console.WriteLine(" Finite state machine compiler tool."); Console.WriteLine(" Copyright 2015-2020 Rafael Serrano ([email protected])"); Console.WriteLine(); XmlLoader loader = new XmlLoader(); Machine machine = loader.Load(sourceFileName); IGenerator generator = null; switch (generatorName) { case "DOT": generator = new DOTGenerator(generatorParameters); break; case "C": default: generator = new CGenerator(generatorParameters); break; case "CPP": generator = new v1.Generator.CPP.CPPGenerator(generatorParameters); break; } generator.Generate(machine); } /* } * * catch (Exception e) { * while (e != null) { * Console.WriteLine(e.Message); * e = e.InnerException; * } * }*/ }
static void Main(string[] args) { try { CmdLineParser cmdLineParser = new CmdLineParser("EosResourceCompiler v1.0"); cmdLineParser.Add(new ArgumentDefinition("source", 1, "Archivo de entrada.", true)); cmdLineParser.Add(new OptionDefinition("O", "Carpeta de salida.")); cmdLineParser.Add(new OptionDefinition("V", "Muestra informacion detallada.")); cmdLineParser.Add(new OptionDefinition("P", "Parametro personalizado.", false, true)); if (args.Length == 0) { Console.WriteLine(cmdLineParser.HelpText); Console.ReadKey(true); } else { CompilerParameters parameters = new CompilerParameters(); string outputFolder = null; string sourceFileName = null; cmdLineParser.Parse(args); foreach (OptionInfo optionInfo in cmdLineParser.Options) { switch (optionInfo.Name) { case "O": outputFolder = optionInfo.Value; break; case "V": parameters.Add("verbose"); break; case "P": parameters.Add(optionInfo.Value); break; } } foreach (ArgumentInfo argumentInfo in cmdLineParser.Arguments) { switch (argumentInfo.Name) { case "source": sourceFileName = argumentInfo.Value; break; } } if (String.IsNullOrEmpty(sourceFileName)) { throw new InvalidOperationException("No se especifico el fichero fuente."); } if (outputFolder == null) { outputFolder = Path.GetDirectoryName(sourceFileName); } ResourcePool resources; using (Stream stream = new FileStream( sourceFileName, FileMode.Open, FileAccess.Read, FileShare.None)) { IResourceReader reader = new ResourceReader(stream); resources = reader.Read(); } IResourceCompiler compiler = new ResourceCompiler(); compiler.Compile(resources, outputFolder, parameters); } } catch (Exception e) { while (e != null) { Console.WriteLine(e.Message); e = e.InnerException; } Console.ReadKey(true); } }
public void TestInitialize() { _parser = new CmdLineParser(); }
public void ShouldThrowIfFlagOptionHasValue() { var builder = new CmdLineInputDefinitionBuilder(); builder.Option("name"); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); Should.Throw<ParserException>(() => parser.Parse(new[] { "-name:value" })); }
static void Run(string commandLine) { CmUtilOption option = null; try { option = new CmdLineParser<CmUtilOption>().Parse(commandLine); } catch (CommandLineParsingException e) { Console.WriteLine(e.Message); ShowUsage(); return; } if (option.Parsed == 0) { ShowUsage(); return; } if (option.Parsed != 1) { Console.WriteLine("Only one option is allowed."); ShowUsage(); return; } if (option.Help) ShowUsage(); else if (option.RunAll) CmTestRunner.RunAllTestCases(); else if (option.RunBatch != null) CmTestRunner.RunFromBatch(option.RunBatch); else if (option.RunTests != null) CmTestRunner.RunTestCases(option.RunTests); }
public void ShouldParseUndefinedOptionIfAllowed() { var builder = new CmdLineInputDefinitionBuilder(); var settings = new CmdLineSettings { UndefinedOptionsPolicy = UndefinedOptionsPolicy.AllowSingleInstance }; var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse("-name:value1;value2"); input.UndefinedOptions.GetSingle("name").ShouldBe(new[] { "value1", "value2" }); }
/// <summary> /// Parses the supplied command-line arguments. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="args"></param> /// <param name="options"></param> /// <returns></returns> public static CmdLineParseResults <T> ParseArgs <T>(IEnumerable <string> args, CmdLineOptions options = null) where T : new() { var parser = new CmdLineParser <T>(options); return(parser.Parse(args)); }
public void ShouldParseParamsArg() { var builder = new CmdLineInputDefinitionBuilder(); builder.Arg("name").IsParams(); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); var input = parser.Parse(new[] { "value1", "value2" }); input.Args.GetAll("name").ShouldBe(new[] { "value1", "value2" }); }
public void ShouldThrowIfUndefinedOptionIsProvidedButNotAllowed() { var builder = new CmdLineInputDefinitionBuilder(); var settings = new CmdLineSettings(); var parser = new CmdLineParser(builder.Definition, settings); Should.Throw<ParserException>(() => parser.Parse("-foobar")).Message.ShouldBe("Unknown option 'foobar'."); }