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);
}
/// <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 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]);
}
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]);
}
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 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" } });
}
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 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 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" });
}
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 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 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 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]);
}
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();
}
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!"));
}
private void ParseCommandLineArguments()
{
string commandLine = CommandLineNoExecutableName();
var parseResult = _parser.Parse <CommandLineOptions>(commandLine);
if (!parseResult.Success)
{
Bail(parseResult.Error);
}
_options = parseResult.Value;
if (!String.IsNullOrEmpty(_options.OutputFileName))
{
try
{
var filePrinter = new FilePrinter(_options.OutputFileName);
_context.Printer = filePrinter;
}
catch (IOException ex)
{
Bail("Error creating output file: {0}", ex.Message);
}
}
}
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 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 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" }));
}
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 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 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'.");
}
/// <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));
}
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 ExecuteOneCommand(string command)
{
InitParserIfNecessary();
string[] parts = command.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length == 0)
{
return;
}
if (parts[0] == "#")
{
return; // Lines starting with # are comments
}
ICommand commandToExecute;
if (IsInDbgEngNativeMode && parts[0] != "q")
{
commandToExecute = new DbgEngCommand()
{
Command = command
};
}
else
{
var parseResult = _commandParser.Parse(_allCommandTypes, command);
if (!parseResult.Success)
{
WriteErrorLine(parseResult.Error);
return;
}
if (parseResult.Value == null)
{
return;
}
commandToExecute = (ICommand)parseResult.Value;
}
using (new TimeAndMemory(DisplayDiagnosticInformation, Printer))
{
try
{
if (!IsCommandIsSupportedForThisTarget(commandToExecute.GetType()))
{
WriteErrorLine("This command is not supported for the current target type: '{0}'", TargetType);
}
else
{
commandToExecute.Execute(this);
}
}
catch (Exception ex)
{
// Commands can throw exceptions occasionally. It's dangerous to continue
// after an arbitrary exception, but some of them are perfectly benign. We are
// taking the risk because there is no critical state that could become corrupted
// as a result of continuing.
WriteErrorLine("Exception during command execution -- {0}: '{1}'", ex.GetType().Name, ex.Message);
WriteErrorLine("\n" + ex.StackTrace);
WriteErrorLine("Proceed at your own risk, or restart the debugging session.");
}
}
if (HyperlinkOutput && _temporaryAliases.Count > WarnThresholdCountOfTemporaryAliases)
{
WriteWarningLine("Hyperlinks are enabled. You currently have {0} temporary aliases. " +
"Use .clearalias --temporary to clear them.", _temporaryAliases.Count);
}
Printer.CommandEnded();
}
public void ParseOneClass_OptionsAndRest()
{
ParseResult <OptionAndRest> result = _parser.Parse <OptionAndRest>("-a 123 alpha beta gamma");
Assert.IsTrue(result.Success);
Assert.IsNotNull(result.Value);
Assert.AreEqual(123, result.Value.Option);
Assert.AreEqual("alpha beta gamma", result.Value.Rest);
}
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;
* }
* }*/
}
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" });
}