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"}}}
};
}
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}}}
};
}
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"}}}}
};
}
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"}}}}
};
}
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"}}}
};
}
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}}}
};
}
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"}}}
}
};
}
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"}}}}
};
}
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}}}
};
}
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"}}}}
};
}
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}}}
};
}
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"}}}
};
}
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"}}}
};
}
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"}}}}
};
}
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}}}
};
}
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"}}}
};
}