static void Main(string[] args)
{
var arguments = ArgsParser.Parse(args);
var c = new AsyncCompressor(arguments.BlockSize);
c.Start(arguments.InputPath, arguments.IsCompression);
}
public void OptionArgumentCaseInsensitive()
{
string[] args = new string[] { "https", "server", "-ClientCertificate" };
ArgsParser argsParser = new ArgsParser(args);
Assert.AreEqual(true, argsParser.HasOption("clientcertificate"));
}
public async Task TestUserParser()
{
const string username = "******";
var origUser = new User(
id: "1234567890", name: username, twitchDisplayName: username.ToUpper(), simpleName: username,
color: null,
firstActiveAt: Instant.FromUnixTimeSeconds(0), lastActiveAt: Instant.FromUnixTimeSeconds(0),
lastMessageAt: null, pokeyen: 0, tokens: 0);
var userRepoMock = new Mock <IUserRepo>();
userRepoMock
.Setup(r => r.FindBySimpleName(username))
.ReturnsAsync(origUser);
var argsParser = new ArgsParser();
argsParser.AddArgumentParser(new UserParser(userRepoMock.Object));
var resultUser = await argsParser.Parse <User>(args : ImmutableList.Create(username));
Assert.AreEqual(origUser, resultUser);
var resultUserPrefixed = await argsParser.Parse <User>(args : ImmutableList.Create('@' + username));
Assert.AreEqual(origUser, resultUserPrefixed);
var ex = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <User>(args: ImmutableList.Create("some_unknown_name")));
Assert.AreEqual("did not recognize a user with the name 'some_unknown_name'", ex.Message);
var exUserPrefixed = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <User>(args: ImmutableList.Create("@some_unknown_name")));
Assert.AreEqual("did not recognize a user with the name 'some_unknown_name'", exUserPrefixed.Message);
}
static void Main(string[] args)
{
try {
bool showHelp = false;
string targetXml = null;
var argsParser = new ArgsParser(Path.GetFileName(Environment.GetCommandLineArgs()[0]), "");
argsParser.AddOption(new ArgOption("?", true, v => showHelp = true, "print this help"));
argsParser.AddOption(new ArgOption("x|xml=", false, v => targetXml = v, "save xml to specified file"));
bool showError = !argsParser.Parse(args, true);
if (showError || showHelp)
{
if (showError)
{
Console.Error.WriteLine("The syntax of the command is incorrect.");
}
Console.Write(argsParser.GetUsage());
if (showError)
{
Environment.Exit(1);
}
}
else
{
BurningDiagramTool.Run(targetXml);
}
} catch (Exception e) {
Console.Error.Write(e.ToStringEx());
Environment.Exit(1);
}
}
public async Task TestTimeSpanParser()
{
var argsParser = new ArgsParser();
argsParser.AddArgumentParser(new TimeSpanParser());
var result1 = await argsParser.Parse <TimeSpan>(args : ImmutableList.Create("8w3d20h48m5s"));
var result2 = await argsParser.Parse <TimeSpan>(args : ImmutableList.Create("90d"));
var expected = new TimeSpan(
days: 8 * 7 + 3,
hours: 20,
minutes: 48,
seconds: 5);
Assert.AreEqual(expected, result1);
Assert.AreEqual(TimeSpan.FromDays(90), result2);
var ex1 = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <TimeSpan>(args: ImmutableList.Create("5s3d")));
var ex2 = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <TimeSpan>(args: ImmutableList.Create("asdasdasd")));
Assert.IsTrue(ex1.Message.Contains("did not recognize '5s3d' as a duration"));
Assert.IsTrue(ex2.Message.Contains("did not recognize 'asdasdasd' as a duration"));
}
public async Task TestAnyOrderParser()
{
var argsParser = new ArgsParser();
argsParser.AddArgumentParser(new AnyOrderParser(argsParser));
argsParser.AddArgumentParser(new StringParser());
argsParser.AddArgumentParser(new IntParser());
var args1 = ImmutableList.Create("123", "foo");
var args2 = ImmutableList.Create("foo", "123");
(int int1, string string1) = await argsParser.Parse <AnyOrder <int, string> >(args1);
(int int2, string string2) = await argsParser.Parse <AnyOrder <int, string> >(args2);
Assert.AreEqual(123, int1);
Assert.AreEqual(123, int2);
Assert.AreEqual("foo", string1);
Assert.AreEqual("foo", string2);
var ex = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <AnyOrder <int, string> >(ImmutableList.Create("foo", "bar")));
Assert.AreEqual(2, ex.Failures.Count);
Assert.AreEqual("did not recognize 'foo' as a number, or did not recognize 'bar' as a number", ex.Message);
}
public async Task TestPkmnSpeciesParser()
{
const string speciesId = "79317";
const string speciesName = "Uniquamon";
var argsParser = new ArgsParser();
PkmnSpecies species = PkmnSpecies.RegisterName(speciesId, speciesName);
argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }));
PkmnSpecies resultById = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("#" + speciesId));
PkmnSpecies resultByPaddedId = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("#0" + speciesId));
PkmnSpecies resultByName1 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create(speciesName));
PkmnSpecies resultByName2 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("uNiQuAmOn"));
Assert.AreEqual(species, resultById);
Assert.AreEqual(species, resultByPaddedId);
Assert.AreEqual(species, resultByName1);
Assert.AreEqual(species, resultByName2);
ArgsParseFailure exNotPrefixed = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create(speciesId)));
Assert.AreEqual("Please prefix with '#' to supply and pokedex number", exNotPrefixed.Message);
ArgsParseFailure exUnknown = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create("unknown")));
Assert.AreEqual(
"No pokemon with the name 'unknown' was recognized. Please supply a valid name, " +
"or prefix with '#' to supply and pokedex number instead", exUnknown.Message);
}
public void ArgsParser_WithArgOptionalArgSet_IsCorrect()
{
var opts = ArgsParser <MyOption> .Parse(new[] { "--flag", "--my-int", "0", "--my-nullable-int", "1" });
Assert.True(opts.MyNullableInt.HasValue);
Assert.Equal(1, opts.MyNullableInt.Value);
}
public void argsParser_should_fail_on_unknown_command()
{
var badCommandArgs = new string[] { "tron", "--input-assembly-path", "test", "-o", "test", "--open-api-file", "test" };
var badCommandArgsParserExitCode = ArgsParser.TryParse(badCommandArgs, out ArgsParser badCommandArgsParser);
badCommandArgsParserExitCode.Should().Be(ExitCode.CommandUnknown);
}
/// <summary>
/// コマンドライン引数をパースして、オプション ディクショナリを組み立てます。
/// </summary>
/// <param name="args">コマンドライン引数。</param>
/// <param name="configOptions">コンフィグから読み込んだオプション。</param>
/// <returns>パース結果のオプション ディクショナリ。</returns>
private static IDictionary <string, IList <string> > ParseArgs(string[] args, IDictionary <string, string[]> configOptions)
{
// コマンドライン オプションのシンタックス。
OptionSyntaxDictionary syntaxes = new OptionSyntaxDictionary {
new OptionSyntax("server", "LDAP サーバーのホスト名または IP アドレス。", 1, 1, new char[] { 's' }, false, true, true),
new OptionSyntax("tls", "LDAPS にする。コンフィグ ファイルで tls を指定した場合も、「--tls off」で LDAP 接続できます。", 0, 1, new char[] { 't' }, false, false, false, new System.Text.RegularExpressions.Regex("^(on|off)$")),
new OptionSyntax("dn", "ユーザー名。", 1, 1, new char[] { 'd' }),
new OptionSyntax("oldpassword", "ユーザー エントリのある DN。", 1, 1, new char[] { 'o' }),
new OptionSyntax("newpassword", "パスワード。", 1, 1, new char[] { 'n' })
};
// パーサー組み立て
var argsParser = new ArgsParser
{
OptionSyntaxDictionary = syntaxes,
ConfigOptionDictionary = configOptions
};
IDictionary <string, IList <string> > options = null;
try
{
// パース処理。
options = argsParser.Parse(args);
}
catch (Exception e)
{
// パースに失敗したら、ヘルプと元の Exception の文字列をいれた Exception を投げる
throw new Exception(syntaxes.GetHelp() + "\n" + e);
}
return(options);
}
public void ArgsParserShort_WithArgOptionalArgSet_IsCorrect()
{
var opts = ArgsParser <MyShortOption> .Parse(new[] { "-f", "-m", "0", "-n", "1" });
Assert.True(opts.MyNullableInt.HasValue);
Assert.Equal(1, opts.MyNullableInt.Value);
}
public void SStartingWithHash_SourceTypeIsRaw()
{
var args = new string[] { "-s", "#X.|.X" };
var parser = new ArgsParser(args);
Assert.AreEqual(InitialWorld.Raw, parser.SourceType);
}
public static ArgsParser SetUpArgsParser(IUserRepo userRepo, PokedexData pokedexData)
{
var argsParser = new ArgsParser();
argsParser.AddArgumentParser(new SignedIntParser());
argsParser.AddArgumentParser(new PositiveIntParser());
argsParser.AddArgumentParser(new NonNegativeIntParser());
argsParser.AddArgumentParser(new StringParser());
argsParser.AddArgumentParser(new InstantParser());
argsParser.AddArgumentParser(new TimeSpanParser());
argsParser.AddArgumentParser(new HexColorParser());
argsParser.AddArgumentParser(new PokeyenParser());
argsParser.AddArgumentParser(new TokensParser());
argsParser.AddArgumentParser(new SignedPokeyenParser());
argsParser.AddArgumentParser(new SignedTokensParser());
argsParser.AddArgumentParser(new PkmnSpeciesParser(pokedexData.KnownSpecies, PokedexData.NormalizeName));
argsParser.AddArgumentParser(new AnyOrderParser(argsParser));
argsParser.AddArgumentParser(new OneOfParser(argsParser));
argsParser.AddArgumentParser(new OptionalParser(argsParser));
argsParser.AddArgumentParser(new ManyOfParser(argsParser));
argsParser.AddArgumentParser(new UserParser(userRepo));
return(argsParser);
}
public async Task TestOneOfParser()
{
var argsParser = new ArgsParser();
argsParser.AddArgumentParser(new OneOfParser(argsParser));
argsParser.AddArgumentParser(new StringParser());
argsParser.AddArgumentParser(new IntParser());
argsParser.AddArgumentParser(new InstantParser());
OneOf <int, string> result1 = await argsParser.Parse <OneOf <int, string> >(ImmutableList.Create("123"));
OneOf <int, string> result2 = await argsParser.Parse <OneOf <int, string> >(ImmutableList.Create("foo"));
Assert.IsTrue(result1.Item1.IsPresent);
Assert.IsFalse(result1.Item2.IsPresent);
Assert.AreEqual(123, result1.Item1.Value);
Assert.IsFalse(result2.Item1.IsPresent);
Assert.IsTrue(result2.Item2.IsPresent);
Assert.AreEqual("foo", result2.Item2.Value);
var exUnrecognized = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <OneOf <int, Instant> >(ImmutableList.Create("foo")));
Assert.AreEqual(2, exUnrecognized.Failures.Count);
const string errorText = "did not recognize 'foo' as a number, or did not recognize 'foo' as a UTC-instant";
Assert.AreEqual(errorText, exUnrecognized.Message);
var exTooManyArgs = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <OneOf <int, int> >(ImmutableList.Create("123", "234")));
Assert.AreEqual("too many arguments", exTooManyArgs.Message);
}
public static void Main(string[] args)
{
try {
config.Port = Utils.GetRandomPort();
config.LANAddr = Utils.GetLocalIp();
if (args == null || args.Length == 0)
{
Logger.Error("args missing or Error\n");
args = new string[] { "--help" };
}
var state = Parser.Default.ParseArguments <SendOptions, ReceiveOptions>(args).MapResult(
(SendOptions o) => ArgsParser.SendSolution(o),
(ReceiveOptions o) => ArgsParser.ReceiveSolution(o),
error => 1
);
if (state != 0)
{
Environment.Exit(1);
}
if (args[0].Equals("--help"))
{
Environment.Exit(1);
}
CreateHostBuilder(new string[] { "--urls", $"http://*:{config.Port}" }).Build().Run();
} catch (Exception e) {
Logger.Error($"internal error occured:{e.Message}");
}
}
public void OmittingW_WidthIsOne()
{
var args = new string[] { "-s", "glider" };
var parser = new ArgsParser(args);
Assert.AreEqual(1, parser.Width);
}
public void OmittingF_FixedIsFalse()
{
var args = new string[] { "-s", "glider" };
var parser = new ArgsParser(args);
Assert.IsFalse(parser.FixedSize);
}
public void ReturnsFalseIfTransformFileDoesNotExist()
{
var argumentParser = new ArgsParser(new[] { "1", "2", "3" });
Assert.False(argumentParser.IsValid(str => str != "2"));
Assert.True(argumentParser.ErrorMessage.Contains(": 2"));
}
public void GivingW40_SetsWidthAs40()
{
var args = new string[] { "-w", "40", "-h", "20" };
var parser = new ArgsParser(args);
Assert.AreEqual(40, parser.Width);
}
public void SGivenPulsar_SourceTypeIsSample()
{
var args = new string[] { "-s", "pulsar" };
var parser = new ArgsParser(args);
Assert.AreEqual(InitialWorld.Sample, parser.SourceType);
}
public void SubparserInCleaningIssueTest()
{
var defaultParser = false;
var pos = 0;
var result = new ArgsParser(new [] { "1" })
.Help("h", "help")
.Comment("Subparser default argparse test")
.Keys("t1", "t2").Tip("first test subparser").Subparser(parser =>
{
if (parser
.Keys("flag").Flag(out var flag)
.Result() != null)
{
return;
}
throw new InvalidOperationException();
})
.Subparser(parser =>
{
if (parser
.Name("pos").Value(out pos)
.Result() != null)
{
return;
}
defaultParser = true;
})
.Result();
Assert.IsNull(result);
Assert.IsTrue(defaultParser);
Assert.AreEqual(1, pos);
}
public void GivingF_FixedIsTrue()
{
var args = new string[] { "-s", "glider", "-f" };
var parser = new ArgsParser(args);
Assert.IsTrue(parser.FixedSize);
}
public void OmittingS_SourceTypeIsRandom()
{
var args = new string[] { "-w", "40", "-h", "40" };
var parser = new ArgsParser(args);
Assert.AreEqual(InitialWorld.Random, parser.SourceType);
}
public void argsParser_should_parse_good_args()
{
var args = new string[] { "generate", "-a", "testAssemblyPath", "-o", "testOutputPath", "-f", "testOpenApiPath" };
var longArgs = new string[] { "_generate", "--input-assembly-path", "testAssemblyPath", "--output-path", "testOutputPath", "--open-api-file", "testOpenApiPath" };
var mixedArgs = new string[] { "generate", "--input-assembly-path", "testAssemblyPath", "-o", "testOutputPath", "--open-api-file", "testOpenApiPath" };
var shortArgsParserExitCode = ArgsParser.TryParse(args, out ArgsParser shortArgsParser);
var longArgsParserExitCode = ArgsParser.TryParse(longArgs, out ArgsParser longArgsParser);
var mixedArgsParserExitCode = ArgsParser.TryParse(mixedArgs, out ArgsParser mixedArgsParser);
shortArgsParserExitCode.Should().Be(ExitCode.Success);
shortArgsParser.Command.Should().Be("generate");
shortArgsParser.InputAssemblyPath.Should().Be("testAssemblyPath");
shortArgsParser.OutputPath.Should().Be("testOutputPath");
shortArgsParser.OpenApiPath.Should().Be("testOpenApiPath");
longArgsParserExitCode.Should().Be(ExitCode.Success);
longArgsParser.Command.Should().Be("_generate");
longArgsParser.InputAssemblyPath.Should().Be("testAssemblyPath");
longArgsParser.OutputPath.Should().Be("testOutputPath");
longArgsParser.OpenApiPath.Should().Be("testOpenApiPath");
mixedArgsParserExitCode.Should().Be(ExitCode.Success);
mixedArgsParser.Command.Should().Be("generate");
mixedArgsParser.InputAssemblyPath.Should().Be("testAssemblyPath");
mixedArgsParser.OutputPath.Should().Be("testOutputPath");
mixedArgsParser.OpenApiPath.Should().Be("testOpenApiPath");
}
public void UnquoteArgVal()
{
int count;
string text;
string[] args;
args = new string[] { "text" };
count = ArgsParser.UnquoteArgVal(args, out text);
Assert.AreEqual(count, 0);
Assert.AreEqual(text, null);
args = new string[] { "\"hello", "my", "dear", "friend\"", "---" };
count = ArgsParser.UnquoteArgVal(args, out text);
Assert.AreEqual(count, 4);
Assert.AreEqual(text, "hello my dear friend");
args = new string[] { "msg=\"hello", "friend\"" };
count = ArgsParser.UnquoteArgVal(args, out text, offset: 4);
Assert.AreEqual(count, 2);
Assert.AreEqual(text, "hello friend");
args = new string[] { "'Dwayne", "\"The", "Rock\"", "Johnson'" };
count = ArgsParser.UnquoteArgVal(args, out text);
Assert.AreEqual(count, 4);
Assert.AreEqual(text, "Dwayne \"The Rock\" Johnson");
args = new string[] { "i", "see", "what", "you", "'did", "there'" };
count = ArgsParser.UnquoteArgVal(args, out text, startIndex: 4);
Assert.AreEqual(count, 2);
Assert.AreEqual(text, "did there");
}
static void Main(string[] args)
{
string errorMessage;
if (ArgsParser.Validate(args, out errorMessage) != true)
{
Console.WriteLine(errorMessage);
Environment.ExitCode = 1; // error
return;
}
try
{
// parse the args
var programArgs = ArgsParser.Parse(args);
// parse the solution file
var testProjects = SolutionParser.GetTestProjects(programArgs.SolutionFile, programArgs.TestsProjectExtension);
// write to nunit project file
NunitWriter.WriteProjectFile(testProjects, programArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Environment.ExitCode = 1; // error
}
Environment.ExitCode = 0; // success
}
private static void WorkingCycle(string[] args, bool launchingWithArgs, Parser parser)
{
bool firstCommand = true;
while (true)
{
if (launchingWithArgs && firstCommand)
{
lastParserResult = parser.ParseArguments(args, quiteableCommands);
lastParserResult
.WithParsed <Command.ICommand>(Execute)
.WithNotParsed(HandleErrorsArgsLaunching);
}
else
{
Console.Write("{0}> ", WorkingDir);
string readParameters = Console.ReadLine();
lastParserResult = parser.ParseArguments(ArgsParser.SplitCommandLine(readParameters ?? string.Empty), notQuiteableCommands);
lastParserResult
.WithParsed <Command.ICommand>(Execute)
.WithNotParsed(HandleErrors);
}
firstCommand = false;
}
}
public static IEnumerable <Argument> ParseOptionTrailingArguments(
this ArgsParser parser)
{
var args = new List <Argument>();
///
while (!parser.Tokenizer.IsEof())
{
if (parser.Tokenizer.MatchOptionToken())
{
break;
}
///
var arg = parser.Tokenizer.MaybeNextArgument();
if (arg == null)
{
break;
}
args.Add(arg);
}
///
return(args);
}
public void SubparserOutCleaningIssueTest()
{
var defaultParser = false;
var result = new ArgsParser(new string [0])
.Help("h", "help")
.Comment("Subparser default argparse test")
.Keys("t1", "t2").Tip("first test subparser").Subparser(parser =>
{
if (parser.Result() != null)
{
return;
}
throw new InvalidOperationException();
})
.Subparser(parser =>
{
if (parser.Result() != null)
{
return;
}
defaultParser = true;
})
.Result();
Assert.IsNull(result);
Assert.IsTrue(defaultParser);
}
public void SGivenPulsar_SourceValIsPulsar()
{
var args = new string[] { "-s", "pulsar" };
var parser = new ArgsParser(args);
Assert.AreEqual("pulsar", parser.Source);
}
public void One_Required_String_Arg_Can_Be_Parsed()
{
var parser = new ArgsParser<ArgsWith1RequiredStringArg>();
var output = parser.Parse(new string[] { "foo" });
Assert.IsNotNull(output);
Assert.AreEqual("foo", output.String1);
}
public void Custom_Names_Can_Be_Parsed()
{
var parser = new ArgsParser<ArgsWithCustomNames>();
var output = parser.Parse(new string[] { "-Foo", "Hello", "-Bar", "World!" });
Assert.IsNotNull(output);
Assert.AreEqual("Hello", output.String1);
Assert.AreEqual("World!", output.String2);
}
public static int Main(string[] args)
{
var parser = new ArgsParser();
parser.Parse(args);
if (parser.Help)
{
DisplayHelpContent();
return 0;
}
try
{
var baseDirectory = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
var assemblyScanner = new AssemblyScanner(baseDirectory);
var configureThisEndpointType = assemblyScanner.GetEndPointType();
var cfg = RunnerConfigurator.New(x =>
{
x.ConfigureService<AppDomainBridge>(s =>
{
s.HowToBuildService(name => new AppDomainBridge(baseDirectory, configureThisEndpointType));
s.WhenStarted(h => h.Start());
s.WhenStopped(h => h.Stop());
});
if ((parser.Username != null) && (parser.Password != null))
x.RunAs(parser.Username, parser.Password);
else
x.RunAsNetworkService();
if (parser.StartManually)
x.DoNotStartAutomatically();
var endpointName = configureThisEndpointType.Assembly.GetName().Name;
var endpointId = string.Format("{0}_v{1}", endpointName, configureThisEndpointType.Assembly.GetName().Version);
x.SetDisplayName(parser.DisplayName ?? endpointId);
x.SetServiceName(parser.ServiceName ?? endpointId);
x.SetDescription(parser.Description ?? string.Format("Colombo Host Service for endpoint {0}.", endpointId));
});
Runner.Host(cfg, args);
return 0;
}
catch (ColomboHostException ex)
{
Console.Error.WriteLine(ex.Message);
return -1;
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
return -1;
}
}
public Rotater( string[] args )
{
this._argsParser = null;
this._globalConfig = new LogrotateConf();
this._filePathConfigSection = new Dictionary<string, LogrotateConf>();
this._status = null;
this.Init( args );
}
public void Optional_String_Arg_Must_Not_Be_Provided()
{
var parser = new ArgsParser<ArgsWith2RequiredAnd1OptionalStringArgs>();
var output = parser.Parse(new string[] { "foo", "bar" });
Assert.IsNotNull(output);
Assert.AreEqual("foo", output.String1);
Assert.AreEqual("bar", output.String2);
Assert.IsNull(output.String3);
}
public void Basic_Types_Can_Be_Parsed()
{
var parser = new ArgsParser<ArgsWithBasicTypes>();
var output = parser.Parse(new string[] { "-String", "Hello", "-Integer", "42", "-Float", "123.4", "-Double", "456.7", "-Boolean" });
Assert.IsNotNull(output);
Assert.AreEqual("Hello", output.String);
Assert.AreEqual(42, output.Integer);
Assert.AreEqual(123.4f, output.Float, 1.0f);
Assert.AreEqual(456.7f, output.Double, 1.0f);
Assert.IsTrue(output.Boolean);
}
public void SetUp()
{
string[] args = { "pathToSite", "--key1", "value1", "--key2", "value2" };
var parser = new ArgsParser();
_dictionary = parser.Parse(args);
}
public void Not_Enough_Args_Is_Exception()
{
var parser = new ArgsParser<ArgsWith1RequiredStringArg>();
parser.Parse(new string[] { });
}
public void Null_Args_Is_Exception()
{
var parser = new ArgsParser<ArgsWith1RequiredStringArg>();
parser.Parse(null);
}
public void Too_Many_Args_Is_Exception()
{
var parser = new ArgsParser<ArgsWith1RequiredStringArg>();
parser.Parse(new string[] { "foo", "bar" });
}
static void TestTriangulationOnSmallGraph(ArgsParser.ArgsParser parser) {
var polyline = new Polyline(
new Point(20.8211097717285, 40.9088821411133),
new Point(21.4894065856934, 46.6845321655273),
new Point(22.9755554199219, 41.3355484008789),
new Point(20.8211097717285, 40.9088821411133));
var polylines = new List<Polyline>();
polylines.Add(polyline);
var points = new List<Point>();
var centroid = new Point(21.7620239257813, 42.9763209025065);
points.Add(centroid);
var testCdt = new Cdt(points, polylines, null);
testCdt.Run();
}
bool Init( string[] args )
{
if ( args.Length == 0 )
{
this.PrintVersion();
this.PrintUsage();
return false;
//Environment.Exit(0);
}
this._argsParser = new ArgsParser( args );
if ( this._argsParser.Usage )
{
this.PrintUsage();
return false;
//Environment.Exit(0);
}
this._status = new LogrotateStatus( this._argsParser.AlternateStateFile );
// now process the config files
foreach ( string str in this._argsParser.ConfigFilePaths )
{
this.ProcessConfigPath( str );
}
return true;
}
static BundlingSettings GetBundlingSettings(ArgsParser.ArgsParser argsParser) {
if (!argsParser.OptionIsUsed(BundlingOption))
return null;
var bs = new BundlingSettings();
string ink = argsParser.GetValueOfOptionWithAfterString(InkImportanceOption);
double inkCoeff;
if (ink != null && double.TryParse(ink, out inkCoeff)) {
bs.InkImportance = inkCoeff;
BundlingSettings.DefaultInkImportance = inkCoeff;
}
string esString = argsParser.GetValueOfOptionWithAfterString(EdgeSeparationOption);
if (esString != null) {
double es;
if (double.TryParse(esString, out es)) {
BundlingSettings.DefaultEdgeSeparation = es;
bs.EdgeSeparation = es;
}
else {
Console.WriteLine("cannot parse {0}", esString);
Environment.Exit(1);
}
}
string capacityCoeffString = argsParser.GetValueOfOptionWithAfterString(CapacityCoeffOption);
if (capacityCoeffString != null) {
double capacityCoeff;
if (double.TryParse(capacityCoeffString, out capacityCoeff)) {
bs.CapacityOverflowCoefficient = capacityCoeff;
}
else {
Console.WriteLine("cannot parse {0}", capacityCoeffString);
Environment.Exit(1);
}
}
return bs;
}
static double GetPaddings(ArgsParser.ArgsParser argsParser, out double loosePadding) {
double tightPadding = 0.5;
if (argsParser.OptionIsUsed(TightPaddingOption)) {
string tightPaddingString = argsParser.GetValueOfOptionWithAfterString(TightPaddingOption);
if (!double.TryParse(tightPaddingString, out tightPadding)) {
Console.WriteLine("cannot parse {0} {1}", TightPaddingOption, tightPaddingString);
Environment.Exit(1);
}
}
loosePadding = 2.25;
if (argsParser.OptionIsUsed(LoosePaddingOption)) {
string loosePaddingString = argsParser.GetValueOfOptionWithAfterString(LoosePaddingOption);
if (!double.TryParse(loosePaddingString, out loosePadding)) {
Console.WriteLine("cannot parse {0} {1}", LoosePaddingOption, loosePaddingString);
Environment.Exit(1);
}
}
return tightPadding;
}
static void RouteBundledEdges(GeometryGraph geometryGraph, ArgsParser.ArgsParser argsParser) {
double loosePadding;
double tightPadding = GetPaddings(argsParser, out loosePadding);
var br = new SplineRouter(geometryGraph, tightPadding, loosePadding, Math.PI/6, new BundlingSettings());
br.Run();
}
static void ProcessMsaglFile(string fileName, ArgsParser.ArgsParser argsParser) {
Graph graph = Graph.Read(fileName);
if (graph == null) {
Console.WriteLine("cannot read " + fileName);
return;
}
if (graph.GeometryGraph != null && graph.BoundingBox.Width > 0) {
//graph does not need a layout
if (argsParser.OptionIsUsed(BundlingOption)) {
RouteBundledEdges(graph.GeometryGraph, argsParser);
if (!argsParser.OptionIsUsed(QuietOption)) {
var gviewer = new GViewer();
gviewer.MouseMove += Draw.GviewerMouseMove;
Form form = CreateForm(graph, gviewer);
form.ShowDialog(); // to block the thread
}
}
}
}
static void ProcessMsaglGeomFile(string fileName, ArgsParser.ArgsParser argsParser) {
}
static void ProcessFile(string fileName, ArgsParser.ArgsParser argsParser, GViewer gViewer, ref int nOfBugs) {
Console.WriteLine("processing " + fileName);
try {
string extension = Path.GetExtension(fileName);
if (extension == ".msagl")
ProcessMsaglFile(fileName, argsParser);
else if (extension == ".dot") {
ProcessDotFile(gViewer, argsParser, fileName);
}
else if (extension == ".geom") {
ProcessMsaglGeomFile(fileName, argsParser);
}
}
catch (Exception e) {
nOfBugs++;
Console.WriteLine("bug " + nOfBugs);
Console.WriteLine(e.ToString());
}
}
static void ProcessListOfFiles(string listOfFilesFile, ArgsParser.ArgsParser argsParser) {
StreamReader sr;
try {
sr = new StreamReader(listOfFilesFile);
}
catch (Exception e) {
Console.WriteLine(e.Message);
return;
}
string fileName;
string dir = Path.GetDirectoryName(listOfFilesFile);
var gviewer = new GViewer();
Form form = FormStuff.CreateForm(gviewer);
int nOfBugs = 0;
while ((fileName = sr.ReadLine()) != null) {
if (String.IsNullOrEmpty(fileName)) continue;
fileName = Path.Combine(dir, fileName.ToLower());
ProcessFile(fileName, argsParser, gviewer, ref nOfBugs);
if (form != null && argsParser.OptionIsUsed(QuietOption) == false)
form.ShowDialog();
}
}
public void Two_Required_String_Args_Can_Be_Parsed()
{
var parser = new ArgsParser<ArgsWith2RequiredStringArgs>();
var output = parser.Parse(new string[] { "foo", "bar" });
Assert.IsNotNull(output);
Assert.AreEqual("foo", output.String1);
Assert.AreEqual("bar", output.String2);
}
public void Two_Required_String_Args_And_One_Optional_String_Arg_Can_Be_Parsed()
{
var parser = new ArgsParser<ArgsWith2RequiredAnd1OptionalStringArgs>();
var output = parser.Parse(new string[] { "foo", "bar", "-String3", "abc" });
Assert.IsNotNull(output);
Assert.AreEqual("foo", output.String1);
Assert.AreEqual("bar", output.String2);
Assert.AreEqual("abc", output.String3);
}
public ArgsParsing()
{
_subject = new ArgsParser();
}
static void ProcessDotFile(GViewer gviewer, ArgsParser.ArgsParser argsParser, string dotFileName) {
int line;
int col;
string msg;
Graph graph = Parser.Parse(dotFileName, out line, out col, out msg);
if (graph == null) {
Console.WriteLine("{0}({1},{2}): error: {3}", dotFileName, line, col, msg);
Environment.Exit(1);
}
if (argsParser.OptionIsUsed(RecoverSugiyamaTestOption)) {
gviewer.CalculateLayout(graph);
graph.GeometryGraph.AlgorithmData = null;
LayeredLayout.RecoverAlgorithmData(graph.GeometryGraph);
Node node = graph.GeometryGraph.Nodes[1];
node.BoundaryCurve = node.BoundaryCurve.Transform(new PlaneTransformation(3, 0, 0, 0, 3, 0));
LayeredLayout.IncrementalLayout(graph.GeometryGraph, node);
gviewer.NeedToCalculateLayout = false;
gviewer.Graph = graph;
gviewer.NeedToCalculateLayout = true;
return;
}
if (argsParser.OptionIsUsed(MdsOption))
graph.LayoutAlgorithmSettings = new MdsLayoutSettings();
else if (argsParser.OptionIsUsed(FdOption))
graph.LayoutAlgorithmSettings = new FastIncrementalLayoutSettings();
if (argsParser.OptionIsUsed(BundlingOption)) {
graph.LayoutAlgorithmSettings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.SplineBundling;
BundlingSettings bs = GetBundlingSettings(argsParser);
graph.LayoutAlgorithmSettings.EdgeRoutingSettings.BundlingSettings = bs;
string ink = argsParser.GetValueOfOptionWithAfterString(InkImportanceOption);
if (ink != null) {
double inkCoeff;
if (double.TryParse(ink, out inkCoeff)) {
bs.InkImportance = inkCoeff;
BundlingSettings.DefaultInkImportance = inkCoeff;
}
else {
Console.WriteLine("cannot parse {0}", ink);
Environment.Exit(1);
}
}
string esString = argsParser.GetValueOfOptionWithAfterString(EdgeSeparationOption);
if (esString != null) {
double es;
if (double.TryParse(esString, out es)) {
BundlingSettings.DefaultEdgeSeparation = es;
bs.EdgeSeparation = es;
}
else {
Console.WriteLine("cannot parse {0}", esString);
Environment.Exit(1);
}
}
}
gviewer.Graph = graph;
}