public void GenerateSwitches(OptionsParser optionsParser) { // here we assume that all descriptors from `descriptors` array // have the same basic attributes (name, description, switches, etc.) // they should differ only in configuration and path SwitchOption = optionsParser.WithOption <bool>(descriptors[0].ShortSwitch ?? Tokenizer.NullCharacter, descriptors[0].LongSwitch); SwitchOption.Description = descriptors[0].Description; if (descriptors[0].ProvidesHelp) { HelpOption = optionsParser.WithOption <bool>(string.Format("help-{0}", descriptors[0].LongSwitch)); HelpOption.Description = string.Format("Show help for {0}", descriptors[0].Name); } }
public void ShouldRecreateMixedShortFlag() { var args = new [] { "-AwB" }; var parser = new OptionsParser(); parser.WithOption <bool>('A'); parser.WithOption <bool>('B'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName); Assert.AreEqual("-w", parser.RecreateUnparsedArguments()); }
public void ShouldRemoveEmptyShortFlagPrefix() { var args = new [] { "-AB" }; var parser = new OptionsParser(); parser.WithOption <bool>('A'); parser.WithOption <bool>('B'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName); Assert.AreEqual(string.Empty, parser.RecreateUnparsedArguments()); }
public void ShouldParseShortSwitchWithStringValue() { var args = new [] { "-nmValue" }; var parser = new OptionsParser(); parser.WithOption <bool>('n'); parser.WithOption <String>('m'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('m', parser.ParsedOptions.Skip(1).First().Flag.ShortName); Assert.AreEqual("Value", parser.ParsedOptions.Skip(1).First().Value); }
public void GenerateSwitches(OptionsParser optionsParser, bool defaultOption = false) { // here we assume that all descriptors from `descriptors` array // have the same basic attributes (name, description, switches, etc.) // they should differ only in configuration and path SwitchOption = optionsParser.WithOption<bool>(descriptors[0].ShortSwitch ?? Tokenizer.NullCharacter, descriptors[0].LongSwitch); SwitchOption.Description = descriptors[0].Description; if(defaultOption) { SwitchOption.Description += " (default)"; } if(descriptors[0].ProvidesHelp) { HelpOption = optionsParser.WithOption<bool>(string.Format("help-{0}", descriptors[0].LongSwitch)); HelpOption.Description = string.Format("Show help for {0}", descriptors[0].Name); } }
public void ShouldDetectLongSwitch() { var args = new [] { "--long" }; var parser = new OptionsParser(); parser.WithOption<bool>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); }
public void ShouldDetectShortSwitch() { var args = new [] { "-c" }; var parser = new OptionsParser(); parser.WithOption <bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); }
public void ShouldDetectLongSwitch() { var args = new [] { "--long" }; var parser = new OptionsParser(); parser.WithOption <bool>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); }
public void ShouldParseLongSwitchWithStringWithAssignmentOperator() { var args = new [] { "--long=test" }; var parser = new OptionsParser(); parser.WithOption <string>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("test", parser.ParsedOptions.First().Value); }
public void ShouldParseOptionWithSpacesInValue() { var args = new [] { "--option=Value with spaces" }; var parser = new OptionsParser(); parser.WithOption <string>("option"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("option", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("Value with spaces", parser.ParsedOptions.First().Value); }
public void ShouldParseShortOptionWithSeparatedValue() { var args = new [] { "-n", "123" }; var parser = new OptionsParser(); parser.WithOption <int>('n'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(123, parser.ParsedOptions.First().Value); }
public void ShouldNotRecreatedParsedValue() { var args = new [] { "--switch", "value" }; var parser = new OptionsParser(); parser.WithOption <string>("switch"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual(args[1], parser.ParsedOptions.First().Value); Assert.IsEmpty(parser.RecreateUnparsedArguments()); }
public void ShouldParseLongSwitchWithValue() { var args = new [] { "--number", "123" }; var parser = new OptionsParser(); parser.WithOption <int>("number"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("number", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual(123, parser.ParsedOptions.First().Value); }
public void ShouldAcceptExpectedValues() { var args = new [] { "-a", "-b", "value-1", "-c", "value-2", "-d", "value-3" }; var parser = new OptionsParser(); parser.WithValue("val1"); parser.WithValue("val2"); parser.WithOption<bool>('a'); parser.WithOption<bool>('b'); parser.WithOption<bool>('c'); parser.WithOption<bool>('d'); parser.Parse(args); Assert.AreEqual(4, parser.ParsedOptions.Count()); Assert.AreEqual('a', parser.ParsedOptions.ElementAt(0).Flag.ShortName); Assert.AreEqual('b', parser.ParsedOptions.ElementAt(1).Flag.ShortName); Assert.AreEqual('c', parser.ParsedOptions.ElementAt(2).Flag.ShortName); Assert.AreEqual('d', parser.ParsedOptions.ElementAt(3).Flag.ShortName); Assert.AreEqual(2, parser.Values.Count()); Assert.AreEqual("value-1", parser.Values.ElementAt(0).Value); Assert.AreEqual("value-2", parser.Values.ElementAt(1).Value); Assert.AreEqual("value-3", parser.RecreateUnparsedArguments()); }
public void ShouldParseOptionValueWithHyphen() { var args = new [] { "-c", "value-with-hyphen" }; var parser = new OptionsParser(); parser.WithOption <string>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual("value-with-hyphen", parser.ParsedOptions.First().Value); Assert.AreEqual(0, parser.UnexpectedArguments.Count()); }
public void ShouldDetectedUnexpectedShortSwitchWithValue() { var args = new [] { "-cx", "value with whitespace" }; var parser = new OptionsParser(); parser.WithOption<bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(2, parser.UnexpectedArguments.Count()); Assert.AreEqual("x", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("value with whitespace", parser.UnexpectedArguments.ElementAt(1).Value); }
public void ShouldAcceptExpectedValues() { var args = new [] { "-a", "-b", "value-1", "-c", "value-2", "-d", "value-3" }; var parser = new OptionsParser(); parser.WithValue("val1"); parser.WithValue("val2"); parser.WithOption <bool>('a'); parser.WithOption <bool>('b'); parser.WithOption <bool>('c'); parser.WithOption <bool>('d'); parser.Parse(args); Assert.AreEqual(4, parser.ParsedOptions.Count()); Assert.AreEqual('a', parser.ParsedOptions.ElementAt(0).Flag.ShortName); Assert.AreEqual('b', parser.ParsedOptions.ElementAt(1).Flag.ShortName); Assert.AreEqual('c', parser.ParsedOptions.ElementAt(2).Flag.ShortName); Assert.AreEqual('d', parser.ParsedOptions.ElementAt(3).Flag.ShortName); Assert.AreEqual(2, parser.Values.Count()); Assert.AreEqual("value-1", parser.Values.ElementAt(0).Value); Assert.AreEqual("value-2", parser.Values.ElementAt(1).Value); Assert.AreEqual("value-3", parser.RecreateUnparsedArguments()); }
public void ShouldDetectUnexpectedShortSwitch() { var args = new [] { "-xc" }; var parser = new OptionsParser(); parser.WithOption <bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("x", parser.UnexpectedArguments.First().Value); }
public void ShouldDetectUnexpectedLongSwitch() { var args = new [] { "--long", "--secondLong" }; var parser = new OptionsParser(); parser.WithOption <bool>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("secondLong", parser.UnexpectedArguments.First().Value); }
public void ShouldRecreateUnparsedArguments() { var args = new [] { "--expected", "-x", "value", "-y1", "--another-expected", "-Aw", "-z'this was unexpected'" }; var parser = new OptionsParser(); parser.WithOption <bool>("expected"); parser.WithOption <bool>("another-expected"); parser.WithOption <bool>('A'); parser.Parse(args); Assert.AreEqual(3, parser.ParsedOptions.Count()); Assert.AreEqual("expected", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("another-expected", parser.ParsedOptions.ElementAt(1).Flag.LongName); Assert.AreEqual(@"-x value -y1 -w ""-z'this was unexpected'""", parser.RecreateUnparsedArguments()); }
public void ShouldDetectedUnexpectedShortSwitchWithValue() { var args = new [] { "-cx", "value with whitespace" }; var parser = new OptionsParser(); parser.WithOption <bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(2, parser.UnexpectedArguments.Count()); Assert.AreEqual("x", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("value with whitespace", parser.UnexpectedArguments.ElementAt(1).Value); }
public void ShouldRecreateUnparsedArgument15() { var args = new[] { "--port=8888", "--no-xwt" }; var parser = new OptionsParser(); parser.WithOption <int>("port"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("port", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual(8888, parser.ParsedOptions.First().Value); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("no-xwt", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("--no-xwt", parser.RecreateUnparsedArguments()); }
public void ShouldRecreateUnparsedArgument13() { var args = new[] { "-n", "123", "--wrong-arg" }; var parser = new OptionsParser(); parser.WithOption <int>('n'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(123, parser.ParsedOptions.First().Value); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments()); }
public void ShouldDetectOptionHavingBothShortAndLongName() { var argsShort = new [] { "-l" }; var argsLong = new [] { "--long" }; foreach (var args in new [] { argsShort, argsLong }) { var parser = new OptionsParser(); parser.WithOption <bool>('l', "long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); var flag = parser.ParsedOptions.First().Flag; Assert.AreEqual('l', flag.ShortName); Assert.AreEqual("long", flag.LongName); } }
public void ShouldRecreateUnparsedArgument7() { var args = new[] { "positional argument", "--port=8888", "--wrong-arg" }; var parser = new OptionsParser(); parser.WithOption <int>("port"); var options = new OptionsWithMultipleArguments(); parser.Parse(options, args); Assert.AreEqual("positional argument", options.Value); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("port", parser.ParsedOptions.ToArray()[0].Flag.LongName); Assert.AreEqual(8888, parser.ParsedOptions.ToArray()[0].Value); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments()); }
public void ShouldRecreateUnparsedArgument3() { var args = new[] { "positional argument", "-p8888", "--wrong-arg" }; var parser = new OptionsParser(); parser.WithOption <int>('p'); var options = new OptionsWithMultipleArguments(); parser.Parse(options, args); Assert.AreEqual("positional argument", options.Value); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('p', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(8888, parser.ParsedOptions.First().Value); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("wrong-arg", parser.UnexpectedArguments.ElementAt(0).Value); Assert.AreEqual("--wrong-arg", parser.RecreateUnparsedArguments()); }
public void ShouldThrowAnExceptionForLongOptionRequiringValueWhenThereIsNone() { var args = new [] { "--long" }; var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true }); parser.WithOption <int>("long"); try { parser.Parse(args); Assert.Fail("Should throw an exception"); } catch (ValidationException e) { Assert.IsTrue(e.Message.Contains("requires parameter of type")); } }
public void ShouldRemoveEmptyShortFlagPrefix() { var args = new [] { "-AB" }; var parser = new OptionsParser(); parser.WithOption<bool>('A'); parser.WithOption<bool>('B'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName); Assert.AreEqual(string.Empty, parser.RecreateUnparsedArguments()); }
public void ShouldParseOptionValueWithHyphen() { var args = new [] { "-c", "value-with-hyphen" }; var parser = new OptionsParser(); parser.WithOption<string>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual("value-with-hyphen", parser.ParsedOptions.First().Value); Assert.AreEqual(0, parser.UnexpectedArguments.Count()); }
public void ShouldDetectOptionHavingBothShortAndLongName() { var argsShort = new [] { "-l" }; var argsLong = new [] { "--long" }; foreach(var args in new [] { argsShort, argsLong }) { var parser = new OptionsParser(); parser.WithOption<bool>('l', "long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); var flag = parser.ParsedOptions.First().Flag; Assert.AreEqual('l', flag.ShortName); Assert.AreEqual("long", flag.LongName); } }
public void ShouldParseLongSwitchWithValue() { var args = new [] { "--number", "123" }; var parser = new OptionsParser(); parser.WithOption<int>("number"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("number", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual(123, parser.ParsedOptions.First().Value); }
public void ShouldParseOptionWithSpacesInValue() { var args = new [] { "--option=Value with spaces" }; var parser = new OptionsParser(); parser.WithOption<string>("option"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("option", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("Value with spaces", parser.ParsedOptions.First().Value); }
public void ShouldDetectUnexpectedShortSwitch() { var args = new [] { "-xc" }; var parser = new OptionsParser(); parser.WithOption<bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("x", parser.UnexpectedArguments.First().Value); }
public void ShouldRecreateUnparsedArguments() { var args = new [] { "--expected", "-x", "value", "-y1", "--another-expected", "-Aw", "-z'this was unexpected'" }; var parser = new OptionsParser(); parser.WithOption<bool>("expected"); parser.WithOption<bool>("another-expected"); parser.WithOption<bool>('A'); parser.Parse(args); Assert.AreEqual(3, parser.ParsedOptions.Count()); Assert.AreEqual("expected", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("another-expected", parser.ParsedOptions.ElementAt(1).Flag.LongName); Assert.AreEqual(@"-x value -y1 -w ""-z'this was unexpected'""", parser.RecreateUnparsedArguments()); }
public void ShouldDetectShortSwitch() { var args = new [] { "-c" }; var parser = new OptionsParser(); parser.WithOption<bool>('c'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('c', parser.ParsedOptions.First().Flag.ShortName); }
public void ShouldParseShortSwitchWithValue() { var args = new [] { "-n123" }; var parser = new OptionsParser(); parser.WithOption<int>('n'); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual(123, parser.ParsedOptions.First().Value); }
public void ShouldNotRecreatedParsedValue() { var args = new [] { "--switch", "value" }; var parser = new OptionsParser(); parser.WithOption<string>("switch"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual(args[1], parser.ParsedOptions.First().Value); Assert.IsEmpty(parser.RecreateUnparsedArguments()); }
public void ShouldRecreateMixedShortFlag() { var args = new [] { "-AwB" }; var parser = new OptionsParser(); parser.WithOption<bool>('A'); parser.WithOption<bool>('B'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('A', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('B', parser.ParsedOptions.Last().Flag.ShortName); Assert.AreEqual("-w", parser.RecreateUnparsedArguments()); }
public void ShouldParseShortSwitchWithStringValue() { var args = new [] { "-nmValue" }; var parser = new OptionsParser(); parser.WithOption<bool>('n'); parser.WithOption<String>('m'); parser.Parse(args); Assert.AreEqual(2, parser.ParsedOptions.Count()); Assert.AreEqual('n', parser.ParsedOptions.First().Flag.ShortName); Assert.AreEqual('m', parser.ParsedOptions.Skip(1).First().Flag.ShortName); Assert.AreEqual("Value", parser.ParsedOptions.Skip(1).First().Value); }
public void ShouldDetectUnexpectedLongSwitch() { var args = new [] { "--long", "--secondLong" }; var parser = new OptionsParser(); parser.WithOption<bool>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual(1, parser.UnexpectedArguments.Count()); Assert.AreEqual("secondLong", parser.UnexpectedArguments.First().Value); }
public void ShouldParseLongSwitchWithStringWithAssignmentOperator() { var args = new [] { "--long=test" }; var parser = new OptionsParser(); parser.WithOption<string>("long"); parser.Parse(args); Assert.AreEqual(1, parser.ParsedOptions.Count()); Assert.AreEqual("long", parser.ParsedOptions.First().Flag.LongName); Assert.AreEqual("test", parser.ParsedOptions.First().Value); }
public void ShouldThrowAnExceptionForShortOptionRequiringValueWhenThereIsNone() { var args = new [] { "-n" }; var parser = new OptionsParser(new ParserConfiguration { ThrowValidationException = true }); parser.WithOption<int>('n'); try { parser.Parse(args); Assert.Fail("Should throw an exception"); } catch (ValidationException e) { Assert.IsTrue(e.Message.Contains("requires parameter of type")); } }