public TestOptionalsSingleDashCombined()
        {
            ArgumentSignatures = new[]
            {
                new Argument("-x") {ActionName = "store_true"},
                new Argument("-yyy") {ActionName = "store_const", ConstValue = 42},
                new Argument("-z")
            };

            Failures = new[]
            {
                "a", "--foo", "-xa", "-x --foo", "-x -z", "-z -x",
                "-yx", "-yz a", "-yyyx", "-yyyza", "-xyza"
            };
            Successes = new SuccessCollection
            {
                {"", new ParseResult {{"x", false}, {"yyy", null}, {"z", null}}},
                {"-x", new ParseResult {{"x", true}, {"yyy", null}, {"z", null}}},
                {"-za", new ParseResult {{"x", false}, {"yyy", null}, {"z", "a"}}},
                {"-z a", new ParseResult {{"x", false}, {"yyy", null}, {"z", "a"}}},
                {"-xza", new ParseResult {{"x", true}, {"yyy", null}, {"z", "a"}}},
                {"-xz a", new ParseResult {{"x", true}, {"yyy", null}, {"z", "a"}}},
                {"-x -za", new ParseResult {{"x", true}, {"yyy", null}, {"z", "a"}}},
                {"-x -z a", new ParseResult {{"x", true}, {"yyy", null}, {"z", "a"}}},
                {"-y", new ParseResult {{"x", false}, {"yyy", 42}, {"z", null}}},
                {"-yyy", new ParseResult {{"x", false}, {"yyy", 42}, {"z", null}}},
                {"-x -yyy -za", new ParseResult {{"x", true}, {"yyy", 42}, {"z", "a"}}},
                {"-x -yyy -z a", new ParseResult {{"x", true}, {"yyy", 42}, {"z", "a"}}}
            };
        }
示例#2
0
 public TestOptionLike()
 {
     ArgumentSignatures = new[]
     {
         new Argument("-x") {TypeName = "float"}, new Argument("-3") {Destination = "y", TypeName = "float"},
         new Argument("z") {ValueCount = new ValueCount("*")}
     };
     Failures = new[]
     {
         "-x", "-y2.5", "-xa", "-x -a", "-x -3", "-x -3.5", "-3 -3.5", "-x -2.5", "-x -2.5 a", "-3 -.5", "a x -1",
         "-x -1 a", "-3 -1 a"
     };
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", null}, {"y", null}, {"z", new object[] {}}}},
         {"-x 2.5", new ParseResult {{"x", 2.5}, {"y", null}, {"z", new object[] {}}}},
         {"-x 2.5 a", new ParseResult {{"x", 2.5}, {"y", null}, {"z", new[] {"a"}}}},
         {"-3.5", new ParseResult {{"x", null}, {"y", 0.5}, {"z", new object[] {}}}},
         {"-3-.5", new ParseResult {{"x", null}, {"y", -0.5}, {"z", new object[] {}}}},
         {"-3 .5", new ParseResult {{"x", null}, {"y", 0.5}, {"z", new object[] {}}}},
         {"a -3.5", new ParseResult {{"x", null}, {"y", 0.5}, {"z", new[] {"a"}}}},
         {"a", new ParseResult {{"x", null}, {"y", null}, {"z", new[] {"a"}}}},
         {"a -x 1", new ParseResult {{"x", 1.0}, {"y", null}, {"z", new[] {"a"}}}},
         {"-x 1 a", new ParseResult {{"x", 1.0}, {"y", null}, {"z", new[] {"a"}}}},
         {"-3 1 a", new ParseResult {{"x", null}, {"y", 1.0}, {"z", new[] {"a"}}}}
     };
 }
 public TestOptionalsRequired()
 {
     ArgumentSignatures = new[] {new Argument("-x") {TypeName = "int", IsRequired = true}};
     Failures = new[] {"a", ""};
     Successes = new SuccessCollection
     {
         {"-x 1", new ParseResult {{"x", 1}}},
         {"-x42", new ParseResult {{"x", 42}}}
     };
 }
 public TestPositionalsChoicesInt()
 {
     ArgumentSignatures = new[] {new Argument("spam") {TypeName = "int", Choices = Enumerable.Range(0,20).Cast<object>().ToList()}};
     Failures = new[] {"", "--foo", "h", "42", "ef"};
     Successes = new SuccessCollection
     {
         {"4", new ParseResult {{"spam", 4}}},
         {"15", new ParseResult {{"spam", 15}}}
     };
 }
示例#5
0
 public TestOptionalsNumeric()
 {
     ArgumentSignatures = new[] {new Argument("-1") {Destination = "one"}};
     Failures = new[] {"-1", "a", "-1 --foo", "-1 -y", "-1 -1", "-1 -2"};
     Successes = new SuccessCollection
     {
         {"-1 a", new ParseResult {{"one", "a"}}},
         {"-1a", new ParseResult {{"one", "a"}}},
         {"-1-2", new ParseResult {{"one", "-2"}}},
     };
 }
 public TestPositionalsNargsZeroOrMoreDefault()
 {
     ArgumentSignatures = new[] {new Argument("foo") {DefaultValue = "bar", ValueCount = new ValueCount("*")}};
     Failures = new[] {"-x"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"foo", "bar"}}},
         {"a", new ParseResult {{"foo", new[] {"a"}}}},
         {"a b", new ParseResult {{"foo", new[] {"a", "b"}}}}
     };
 }
示例#7
0
 public TestOptionalsActionAppendWithDefault()
 {
     ArgumentSignatures = new[] {new Argument("--baz") {ActionName = "append", DefaultValue = new[] {"X"}}};
     Failures = new[] {"a", "--baz", "a --baz", "--baz a b"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"baz", new[] {"X"}}}},
         {"--baz a", new ParseResult {{"baz", new[] {"X", "a"}}}},
         {"--baz a --baz b", new ParseResult {{"baz", new[] {"X", "a", "b"}}}}
     };
 }
示例#8
0
 public TestNargsRemainder()
 {
     ArgumentSignatures = new[] {new Argument("x"), new Argument("y") {IsRemainder = true}, new Argument("-z")};
     Failures = new[] {"", "-z", "-z Z"};
     Successes = new SuccessCollection
     {
         {"X", new ParseResult {{"x", "X"}, {"y", new object[] {}}, {"z", null}}},
         {"-z Z X", new ParseResult {{"x", "X"}, {"y", new object[] {}}, {"z", "Z"}}},
         {"X A B -z Z", new ParseResult {{"x", "X"}, {"y", new[] {"A", "B", "-z", "Z"}}, {"z", null}}},
         {"X Y --foo", new ParseResult {{"x", "X"}, {"y", new[] {"Y", "--foo"}}, {"z", null}}}
     };
 }
 public TestOptionalsDoubleDash()
 {
     ArgumentSignatures = new[] {new Argument("--foo")};
     Failures = new[] {"--foo", "-f", "-f a", "a", "--foo -x", "--foo --bar"};
     Successes = new SuccessCollection
     {
         {"--foo a", new ParseResult {{"foo", "a"}}},
         {"--foo=a", new ParseResult {{"foo", "a"}}},
         {"--foo -2.5", new ParseResult {{"foo", "-2.5"}}},
         {"--foo=-2.5", new ParseResult {{"foo", "-2.5"}}}
     };
 }
 public TestOptionalsSingleDash()
 {
     ArgumentSignatures = new[] {new Argument("-x")};
     Failures = new[] {"-x", "a", "--foo", "-x --foo", "-x -y"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", null}}},
         {"-x a", new ParseResult {{"x", "a"}}},
         {"-xa", new ParseResult {{"x", "a"}}},
         {"-x -1", new ParseResult {{"x", "-1"}}},
         {"-x-1", new ParseResult {{"x", "-1"}}}
     };
 }
 public TestOptionalsSingleDashLong()
 {
     ArgumentSignatures = new[] {new Argument("-foo")};
     Failures = new[] {"-foo", "a", "--foo", "-foo --foo", "-foo -y", "-fooa"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"foo", null}}},
         {"-foo a", new ParseResult {{"foo", "a"}}},
         {"-foo -1", new ParseResult {{"foo", "-1"}}},
         {"-fo a", new ParseResult {{"foo", "a"}}},
         {"-f a", new ParseResult {{"foo", "a"}}}
     };
 }
 public TestOptionalsDoubleDashPartialMatch()
 {
     ArgumentSignatures = new[] {new Argument("--badger") {ActionName = "store_true"}, new Argument("--bat")};
     Failures = new[] {"--bar", "--b", "--ba", "--b=2", "--ba=4", "--badge 5"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"badger", false}, {"bat", null}}},
         {"--bat X", new ParseResult {{"badger", false}, {"bat", "X"}}},
         {"--bad", new ParseResult {{"badger", true}, {"bat", null}}},
         {"--badg", new ParseResult {{"badger", true}, {"bat", null}}},
         {"--badge", new ParseResult {{"badger", true}, {"bat", null}}},
         {"--badger", new ParseResult {{"badger", true}, {"bat", null}}}
     };
 }
 public TestPositionalsChoicesString()
 {
     ArgumentSignatures = new[]
     {
         new Argument("spam")
         {
             Choices = new [] {"a", "b", "c", "d", "e", "f", "g"}
         }
     };
     Failures = new[] {"", "--foo", "h", "42", "ef"};
     Successes = new SuccessCollection
     {
         {"a", new ParseResult {{"spam", "a"}}},
         {"g", new ParseResult {{"spam", "g"}}}
     };
 }
 public TestOptionalsAlternatePrefixCharsMultipleShortArgs()
 {
     ParserSignature = new ParserSettings {Prefixes = new[] {"+", "-"}};
     ArgumentSignatures = new[]
     {
         new Argument("-x") {ActionName = "store_true"}, new Argument("+y") {ActionName = "store_true"},
         new Argument("+z") {ActionName = "store_true"}
     };
     Failures = new[] {"-w", "-xyz", "+x", "-y", "+xyz"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", false}, {"y", false}, {"z", false}}},
         {"-x", new ParseResult {{"x", true}, {"y", false}, {"z", false}}},
         {"+y -x", new ParseResult {{"x", true}, {"y", true}, {"z", false}}},
         {"+yz -x", new ParseResult {{"x", true}, {"y", true}, {"z", true}}}
     };
 }
 public TestEmptyAndSpaceContainingArguments()
 {
     ArgumentSignatures = new[]
     {new Argument("x") {ValueCount = new ValueCount("?")}, new Argument("-y", "--yyy") {Destination = "y"}};
     Failures = new[] {"-y"};
     Successes = new SuccessCollection
     {
         {new[] {""}, new ParseResult {{"x", ""}, {"y", null}}},
         {new[] {"a badger"}, new ParseResult {{"x", "a badger"}, {"y", null}}},
         {new[] {"-a badger"}, new ParseResult {{"x", "-a badger"}, {"y", null}}},
         {new[] {"-y", ""}, new ParseResult {{"x", null}, {"y", ""}}},
         {new[] {"-y", "a badger"}, new ParseResult {{"x", null}, {"y", "a badger"}}},
         {new[] {"-y", "-a badger"}, new ParseResult {{"x", null}, {"y", "-a badger"}}},
         {new[] {"--yyy=a badger"}, new ParseResult {{"x", null}, {"y", "a badger"}}},
         {new[] {"--yyy=-a badger"}, new ParseResult {{"x", null}, {"y", "-a badger"}}}
     };
 }
示例#16
0
 public TestOptionalsChoices()
 {
     ArgumentSignatures = new[]
     {
         new Argument("-f") {Choices = new [] {"a", "b", "c"}},
         new Argument("-g") {TypeName = "int", Choices = Enumerable.Range(0, 5).Cast<object>().ToArray()}
     };
     Failures = new[] {"a", "-f d", "-fad", "-ga", "-g 6"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"f", null}, {"g", null}}},
         {"-f a", new ParseResult {{"f", "a"}, {"g", null}}},
         {"-f c", new ParseResult {{"f", "c"}, {"g", null}}},
         {"-g 0", new ParseResult {{"f", null}, {"g", 0}}},
         {"-g 03", new ParseResult {{"f", null}, {"g", 3}}},
         {"-fb -g4", new ParseResult {{"f", "b"}, {"g", 4}}}
     };
 }
 public TestOptionalsSingleDashSubsetAmbiguous()
 {
     ArgumentSignatures = new[]
     {
         new Argument("-f"), new Argument("-foobar"), new Argument("-foorab")
     };
     Failures = new[] {"-f", "-foo", "-fo", "-foo b", "-foob", "-fooba", "-foora"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"f", null}, {"foobar", null}, {"foorab", null}}},
         {"-f a", new ParseResult {{"f", "a"}, {"foobar", null}, {"foorab", null}}},
         {"-fa", new ParseResult {{"f", "a"}, {"foobar", null}, {"foorab", null}}},
         {"-foa", new ParseResult {{"f", "oa"}, {"foobar", null}, {"foorab", null}}},
         {"-fooa", new ParseResult {{"f", "ooa"}, {"foobar", null}, {"foorab", null}}},
         {"-foobar a", new ParseResult {{"f", null}, {"foobar", "a"}, {"foorab", null}}},
         {"-foorab a", new ParseResult {{"f", null}, {"foobar", null}, {"foorab", "a"}}}
     };
 }
 public TestOptionalsSingleDoubleDash()
 {
     ArgumentSignatures = new[]
     {
         new Argument("-f") {ActionName = "store_true"}, new Argument("--bar"),
         new Argument("-baz") {ActionName = "store_const", ConstValue = 42}
     };
     Failures = new[] {"--bar", "-fbar", "-fbaz", "-bazf", "-b B", "B"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"bar", null}, {"baz", null}, {"f", false}}},
         {"-f", new ParseResult {{"bar", null}, {"baz", null}, {"f", true}}},
         {"--ba B", new ParseResult {{"bar", "B"}, {"baz", null}, {"f", false}}},
         {"-f --bar B", new ParseResult {{"bar", "B"}, {"baz", null}, {"f", true}}},
         {"-f -b", new ParseResult {{"bar", null}, {"baz", 42}, {"f", true}}},
         {"-ba -f", new ParseResult {{"bar", null}, {"baz", 42}, {"f", true}}}
     };
 }
示例#19
0
 public TestOptionalsActionAppendConst()
 {
     ArgumentSignatures = new[]
     {
         new Argument("-b") {ActionName = "append_const", ConstValue = typeof (Exception)},
         new Argument("-c") {ActionName = "append", Destination = "b"}
     };
     Failures = new[] {"a", "-c", "a -c", "-bx", "-b x"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"b", null}}},
         {"-b", new ParseResult {{"b", new[] {typeof (Exception)}}}},
         {
             "-b -cx -b -cyz",
             new ParseResult {{"b", new object[] {typeof (Exception), "x", typeof (Exception), "yz"}}}
         }
     };
 }
示例#20
0
        public TestNargsZeroOrMore()
        {
            ArgumentSignatures = new[]
            {
                new Argument("-x") {ValueCount = new ValueCount("*")},
                new Argument("y") {ValueCount = new ValueCount("*")}
            };

            Successes = new SuccessCollection
            {
                {"", new ParseResult {{"x", null}, {"y", new object[] {}}}},
                {"-x", new ParseResult {{"x", new object[] {}}, {"y", new object[] {}}}},
                {"-x a", new ParseResult {{"x", new object[] {"a"}}, {"y", new object[] {}}}},
                {"-x a -- b", new ParseResult {{"x", new object[] {"a"}}, {"y", new object[] {"b"}}}},
                {"a", new ParseResult {{"x", null}, {"y", new object[] {"a"}}}},
                {"a -x", new ParseResult {{"x", new object[] {}}, {"y", new object[] {"a"}}}},
                {"a -x b", new ParseResult {{"x", new object[] {"b"}}, {"y", new object[] {"a"}}}}
            };
        }
示例#21
0
 public TestDefaultSuppress()
 {
     ArgumentSignatures = new[]
     {
         new Argument("foo") {ValueCount = new ValueCount("?"), SuppressDefaultValue = true},
         new Argument("bar") {ValueCount = new ValueCount("*"), SuppressDefaultValue = true},
         new Argument("--baz") {ActionName = "store_true", SuppressDefaultValue = true}
     };
     Failures = new[] {"-x"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {}},
         {"a", new ParseResult {{"foo", "a"}}},
         {"a b", new ParseResult {{"bar", new[] {"b"}}, {"foo", "a"}}},
         {"--baz", new ParseResult {{"baz", true}}},
         {"a --baz", new ParseResult {{"baz", true}, {"foo", "a"}}},
         {"--baz a b", new ParseResult {{"bar", new[] {"b"}}, {"baz", true}, {"foo", "a"}}}
     };
 }
 public TestOptionalsAlternatePrefixChars()
 {
     ParserSignature = new ParserSettings { Prefixes = new[] { "+", ":", "/", "::" } };
     ArgumentSignatures = new[]
     {
         new Argument("+f") {ActionName = "store_true"}, new Argument("::bar"),
         new Argument("/baz") {ActionName = "store_const", ConstValue = 42}
     };
     Failures = new[] { "--bar", "-fbar", "-b B", "B", "-f", "--bar B", "-baz", "-h", "--help", "+h", "::help", "/help" };
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"bar", null}, {"baz", null}, {"f", false}}},
         {"+f", new ParseResult {{"bar", null}, {"baz", null}, {"f", true}}},
         {"::ba B", new ParseResult {{"bar", "B"}, {"baz", null}, {"f", false}}},
         {"+f ::bar B", new ParseResult {{"bar", "B"}, {"baz", null}, {"f", true}}},
         {"+f /b", new ParseResult {{"bar", null}, {"baz", 42}, {"f", true}}},
         {"/ba +f", new ParseResult {{"bar", null}, {"baz", 42}, {"f", true}}}
     };
 }
 public TestPrefixCharacterOnlyArguments()
 {
     ParserSignature = new ParserSettings { Prefixes = new[] { "-", "+" } };
     ArgumentSignatures = new[]
     {
         new Argument("-") {ConstValue = "badger", Destination = "x", ValueCount = new ValueCount("?")},
         new Argument("+") {Destination = "y", DefaultValue = 42, Type = typeof(int)},
         new Argument("-+-") {ActionName = "store_true", Destination = "z"}
     };
     Failures = new[] {"-y", "+ -"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", null}, {"y", 42}, {"z", false}}},
         {"-", new ParseResult {{"x", "badger"}, {"y", 42}, {"z", false}}},
         {"- X", new ParseResult {{"x", "X"}, {"y", 42}, {"z", false}}},
         {"+ -3", new ParseResult {{"x", null}, {"y", -3}, {"z", false}}},
         {"-+-", new ParseResult {{"x", null}, {"y", 42}, {"z", true}}},
         {"- ===", new ParseResult {{"x", "==="}, {"y", 42}, {"z", false}}}
     };
 }
示例#24
0
 public TestPositionalsNargsOneOrMore1()
 {
     ArgumentSignatures = new[]
     {
         new Argument("foo") {ValueCount = new ValueCount("+")},
         new Argument("bar") {ValueCount = new ValueCount(1)}
     };
     Failures = new[] {"", "--foo", "a"};
     Successes = new SuccessCollection
     {
         {"a b", new ParseResult {{"bar", new[] {"b"}}, {"foo", new[] {"a"}}}},
         {"a b c", new ParseResult {{"bar", new[] {"c"}}, {"foo", new[] {"a", "b"}}}}
     };
 }
示例#25
0
 public TestPositionalsNargsOptionalConvertedDefault()
 {
     ArgumentSignatures = new[]
     {new Argument("foo") {DefaultValue = "42", ValueCount = new ValueCount("?"), TypeName = "int"}};
     Failures = new[] {"-x", "a b", "1 2"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"foo", 42}}},
         {"1", new ParseResult {{"foo", 1}}}
     };
 }
示例#26
0
 public TestPositionalsNargsOptionalOptional()
 {
     ArgumentSignatures = new[]
     {
         new Argument("foo") {ValueCount = new ValueCount("?")},
         new Argument("bar") {DefaultValue = 42, ValueCount = new ValueCount("?")}
     };
     Failures = new[] {"--foo", "a b c"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"bar", 42}, {"foo", null}}},
         {"a", new ParseResult {{"bar", 42}, {"foo", "a"}}},
         {"a b", new ParseResult {{"bar", "b"}, {"foo", "a"}}}
     };
 }
示例#27
0
 public TestOptionalsActionStore()
 {
     ArgumentSignatures = new[] {new Argument("-x") {ActionName = "store"}};
     Failures = new[] {"a", "a -x"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", null}}},
         {"-xfoo", new ParseResult {{"x", "foo"}}}
     };
 }
示例#28
0
 public TestPositionalsNargsZeroOrMoreNone()
 {
     ArgumentSignatures = new[] {new Argument("foo") {ValueCount = new ValueCount("*")}, new Argument("bar")};
     Failures = new[] {"", "--foo"};
     Successes = new SuccessCollection
     {
         {"a", new ParseResult {{"bar", "a"}, {"foo", new object[] {}}}},
         {"a b", new ParseResult {{"bar", "b"}, {"foo", new[] {"a"}}}},
         {"a b c", new ParseResult {{"bar", "c"}, {"foo", new[] {"a", "b"}}}}
     };
 }
示例#29
0
 public TestOptionalsActionCount()
 {
     ArgumentSignatures = new[] {new Argument("-x") {ActionName = "count"}};
     Failures = new[] {"a", "-x a", "-x b", "-x a -x b"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"x", null}}},
         {"-x", new ParseResult {{"x", 1}}}
     };
 }
示例#30
0
 public TestPositionalsNargsOptional()
 {
     ArgumentSignatures = new[] {new Argument("foo") {ValueCount = new ValueCount("?")}};
     Failures = new[] {"-x", "a b"};
     Successes = new SuccessCollection
     {
         {"", new ParseResult {{"foo", null}}},
         {"a", new ParseResult {{"foo", "a"}}}
     };
 }