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());
}
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();
}
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 TestInitialize()
{
_parser = new CmdLineParser();
}
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 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'.");
}
private void InitParserIfNecessary()
{
if (_commandParser == null)
{
_commandParser = new CmdLineParser(new PrinterTextWriter(Printer));
_allCommandTypes = GetAllCommandTypes();
}
}
