void should_get_value_when_parsing_args_contain_valid_combined_flags_and_valid_single_flag()
{
var fullName1 = "flag";
var abbreviation1 = 'f';
var fullName2 = "flagSecond";
var abbreviation2 = 's';
var fullName3 = "flagThird";
var abbreviation3 = 't';
var parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption(fullName1, abbreviation1, String.Empty)
.AddFlagOption(fullName2, abbreviation2, String.Empty)
.AddFlagOption(fullName3, abbreviation3, String.Empty)
.EndCommand()
.Build();
var argsParsingResult = parser.Parser(new[] { "-fs", "-t" });
Assert.True(argsParsingResult.GetFlagValue("-t"));
}
public void should_get_free_value_not_supported_for_specified_command()
{
// start-(unresolved command)->default command ? error
const string commandName = "command";
ArgsParser parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.EndCommand()
.BeginCommand(commandName, string.Empty)
.EndCommand()
.Build();
string[] args = { "not_matched_command" };
ArgsParsingResult result = parser.Parse(args);
result.AssertError(
ArgsParsingErrorCode.FreeValueNotSupported,
"not_matched_command");
}
void should_success_add_multiple_flags()
{
var fullName1 = "flag";
var abbreviation1 = 'f';
var fullName2 = "flagSecond";
var abbreviation2 = 'S';
var parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption(fullName1, abbreviation1, null)
.AddFlagOption(fullName2, abbreviation2, null)
.EndCommand()
.Build();
ArgsParsingResult result = parser.Parser(new[] { "--flag" });
Assert.True(result.IsSuccess);
Assert.True(result.GetFlagValue("-f"));
}
public void should_parse_success_when_parse_twice()
{
ArgsParser parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption("read", 'r')
.AddFlagOption("force", 'f')
.EndCommand()
.Build();
ArgsParsingResult argsParsingResult = parser.Parse(new [] { "-r" });
Assert.True(argsParsingResult.IsSuccess);
Assert.True(argsParsingResult.GetFlagValue("--read"));
Assert.False(argsParsingResult.GetFlagValue("-f"));
parser.Parse(new [] { "-f" });
Assert.True(argsParsingResult.IsSuccess);
Assert.False(argsParsingResult.GetFlagValue("--read"));
Assert.True(argsParsingResult.GetFlagValue("-f"));
}
public void should_get_all_options_when_get_registered_options_metadata_from_command()
{
ArgsParser parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption("flag", 'f', "flag description")
.EndCommand()
.Build();
ArgsParsingResult result = parser.Parse(new [] { "--flag" });
Assert.True(result.IsSuccess);
IOptionDefinitionMetadata[] optionDefinitionMetadatas =
result.Command.GetRegisteredOptionsMetadata().ToArray();
IOptionDefinitionMetadata flagMetadata =
optionDefinitionMetadatas.Single(
d => d.SymbolMetadata.FullForm.Equals("flag",
StringComparison.OrdinalIgnoreCase));
Assert.Equal("flag", flagMetadata.SymbolMetadata.FullForm);
Assert.Equal('f', flagMetadata.SymbolMetadata.Abbreviation);
Assert.Equal("flag description", flagMetadata.Description);
}
public void should_get_the_named_definition_basic_information()
{
const string name = "free_value_name";
const string description = "description";
ArgsParser parser = new ArgsParserBuilder()
.BeginCommand("command", string.Empty)
.AddFreeValue(name, description, false, IntegerTransformer.Instance)
.EndCommand()
.Build();
ArgsParsingResult result = parser.Parse(new[] { "command", "123" });
result.AssertSuccess();
Assert.True(result.Command.AllowFreeValue);
IFreeValueDefinitionMetadata definition = result.Command.GetRegisteredFreeValuesMetadata().Single();
Assert.Equal(name, definition.Name);
Assert.Equal(description, definition.Description);
Assert.Same(IntegerTransformer.Instance, definition.Transformer);
}
void should_parse_valid_combined_flags_successfully_no_matter_the_order()
{
var fullName1 = "flag";
var abbreviation1 = 'f';
var fullName2 = "flagSecond";
var abbreviation2 = 's';
var parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption(fullName1, abbreviation1, String.Empty)
.AddFlagOption(fullName2, abbreviation2, String.Empty)
.EndCommand()
.Build();
var argsParsingResult = parser.Parser(new[] { "-fs" });
Assert.True(argsParsingResult.IsSuccess);
Assert.Null(argsParsingResult.Error);
var anotherOrderArgsParsingResult = parser.Parser(new[] { "-sf" });
Assert.True(anotherOrderArgsParsingResult.IsSuccess);
Assert.Null(anotherOrderArgsParsingResult.Error);
}
public void should_throw_ArgumentException_when_get_the_third_flag_value_without_parse_the_third_flag()
{
var fullName1 = "flag";
var abbreviation1 = 'f';
var fullName2 = "flagSecond";
var abbreviation2 = 's';
var fullName3 = "flagThird";
var abbreviation3 = 't';
var parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption(fullName1, abbreviation1, String.Empty)
.AddFlagOption(fullName2, abbreviation2, String.Empty)
.AddFlagOption(fullName3, abbreviation3, String.Empty)
.EndCommand()
.Build();
ArgsParsingResult result = parser.Parser(new[] { "-fs" });
Assert.True(result.IsSuccess);
Assert.True(result.GetFlagValue("-f"));
Assert.True(result.GetFlagValue("-s"));
Assert.Throws <ArgumentException>(() => result.GetFlagValue("-t"));
}
static int Main(string[] args)
{
ArgsParser parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddOptionWithValue("kind", 'k', "Specify the kind of maze to render.", true)
.AddOptionWithValue("row", 'r', "Specify the number of rows in the maze.", true,
new IntegerTransformer())
.AddOptionWithValue("column", 'c', "Specify the number of columns in the maze.", true,
new IntegerTransformer())
.EndCommand()
.Build();
ArgsParsingResult argsParsingResult = parser.Parse(args);
if (!argsParsingResult.IsSuccess)
{
PrintUsage(argsParsingResult.Error.Code.ToString(), argsParsingResult.Error.Trigger);
return((int)argsParsingResult.Error.Code);
}
string imagePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "maze.png");
return(RenderPredefinedMaze(argsParsingResult, imagePath));
}
public void should_parse_success_and_can_get_flag_value_when_flag_has_two_valid_names()
{
var fullName = "flag";
var abbrName = 'f';
var description = "the first flag";
ArgsParser parser = new ArgsParserBuilder()
.BeginDefaultCommand()
.AddFlagOption(fullName, abbrName, description)
.EndCommand()
.Build();
ArgsParsingResult result = parser.Parser(new[] { "-f" });
Assert.True(result.IsSuccess);
Assert.True(result.GetFlagValue("--flag"));
Assert.Null(result.Error);
ArgsParsingResult result2 = parser.Parser(new[] { "--flag" });
Assert.True(result2.IsSuccess);
Assert.True(result2.GetFlagValue("-f"));
Assert.Null(result2.Error);
}
public void should_throw_if_full_form_is_invalid_for_flag(string invalidFullForm)
{
CommandBuilder builder = new ArgsParserBuilder().BeginDefaultCommand();
Assert.Throws <ArgumentException>(() => builder.AddFlagOption(invalidFullForm, null, string.Empty));
}
public void should_not_be_null_for_both_fullname_and_abbreviation_for_flag()
{
CommandBuilder builder = new ArgsParserBuilder().BeginDefaultCommand();
Assert.Throws <ArgumentException>(() => builder.AddFlagOption(null, null, string.Empty));
}
internal CommandBuilder(ArgsParserBuilder argsParserBuilder)
{
ArgsParserBuilder = argsParserBuilder;
}
void should_throw_ArgumentException_when_parse_args_with_null()
{
var parser = new ArgsParserBuilder().BeginDefaultCommand().AddFlagOption("flag", 'f').EndCommand().Build();
Assert.Equal("cannot parse args with null", Assert.Throws <ArgumentException>(() => parser.Parse(new [] { "-f", null })).Message);
}
void should_throw_ArgumentNullException_when_parse_null_args()
{
var parser = new ArgsParserBuilder().BeginDefaultCommand().AddFlagOption("flag", 'f').EndCommand().Build();
Assert.Throws <ArgumentNullException>(() => parser.Parse(null));
}
void should_throw_ArgumentException_when_add_conflict_flag(string fullForm1, char?abbrevationForm1, string fullForm2, char?abbrevationForm2, string errorMessage)
{
var builder = new ArgsParserBuilder().BeginDefaultCommand().AddFlagOption(fullForm1, abbrevationForm1);
Assert.Equal(errorMessage, Assert.Throws <ArgumentException>(() => builder.AddFlagOption(fullForm2, abbrevationForm2)).Message);
}
public void should_throw_if_abbr_form_is_invalid_for_flag(char invalidAbbrForm)
{
CommandBuilder builder = new ArgsParserBuilder().BeginDefaultCommand();
Assert.Throws <ArgumentException>(() => builder.AddFlagOption("name", invalidAbbrForm, string.Empty));
}
internal CommandBuilder(ArgsParserBuilder parserBuilder)
{
this.parserBuilder = parserBuilder;
command = new DefaultCommand();
}
public when_begin_default_command()
{
builder = new ArgsParserBuilder();
}
public void should_throw_if_free_value_name_is_null()
{
CommandBuilder builder = new ArgsParserBuilder().BeginDefaultCommand();
Assert.Throws <ArgumentNullException>(() => builder.AddFreeValue(null, string.Empty));
}
public when_build_a_parser()
{
builder = new ArgsParserBuilder();
}
