public void TestUnnamedParmeters()
{
var args = new string[] { "input", "output" };
var attributeParser = new ByAttributeParser <TwoUnnamedParameters>();
var parser = attributeParser.PrepareParser(args);
Assert.That(parser.UnnamedArgumentInfos.Count(), Is.EqualTo(2));
Assert.That(parser.UnnamedArgumentInfos.ElementAt(0).Index, Is.EqualTo(0));
Assert.That(parser.UnnamedArgumentInfos.ElementAt(1).Index, Is.EqualTo(1));
Assert.That(parser.NamedArgumentInfos.Count(), Is.EqualTo(0));
var result = attributeParser.FillObject();
Assert.That(result, Is.Not.Null);
Assert.That(result.Input, Is.EqualTo("input"));
Assert.That(result.Output, Is.EqualTo("output"));
// Try to provoke an error
args = new string[] { };
attributeParser = new ByAttributeParser <TwoUnnamedParameters>();
parser = attributeParser.PrepareParser(args);
var parseResult = parser.ParseOrShowUsage();
result = attributeParser.FillObject();
Assert.That(parseResult, Is.False);
Assert.That(parser.Errors.Count, Is.EqualTo(1));
}
public void TestConversionOfAttributes()
{
var args = new string[] { };
var attributeParser = new ByAttributeParser <Parameters>();
var parser = attributeParser.PrepareParser(args);
Assert.That(parser, Is.Not.Null);
var infos = parser.ArgumentInfos;
Assert.That(infos.Count(), Is.EqualTo(2));
var namedArgumentInfos = infos.Where(x => x is NamedArgumentInfo);
var unnamedArgumentInfos = infos.Where(x => x is UnnamedArgumentInfo);
Assert.That(unnamedArgumentInfos.Count(), Is.EqualTo(1));
Assert.That(namedArgumentInfos.Count(), Is.EqualTo(1));
var namedArgument = namedArgumentInfos.First() as NamedArgumentInfo;
var unnamedArgument = unnamedArgumentInfos.First() as UnnamedArgumentInfo;
Assert.That(namedArgument.ShortName, Is.EqualTo('v'));
Assert.That(namedArgument.DefaultValue, Is.EqualTo("1"));
Assert.That(namedArgument.HelpText, Is.EqualTo("Input text"));
Assert.That(unnamedArgument.Index, Is.EqualTo(1));
Assert.That(unnamedArgument.DefaultValue, Is.EqualTo("Default Value"));
Assert.That(unnamedArgument.HelpText, Is.EqualTo("Input text"));
}
/// <summary>
/// Parses the value into the a new instance of the given object type
/// </summary>
/// <typeparam name="T">Type to be created </typeparam>
/// <returns>The created type, which received the argument</returns>
/// <remarks>This class somehow violates the layering between Parser and the
/// attribute-driven parser. To ease the use of the attribute-driven parser,
/// the static method is included here and not in the class ByAttributeParser</remarks>
public static T ParseIntoOrShowUsage <T>(string[] args) where T : class, new()
{
var byAttributeParser = new ByAttributeParser <T>();
var parser = byAttributeParser.PrepareParser(args);
parser.Parse();
if (parser.ShowUsageIfNecessary())
{
return(null);
}
var result = byAttributeParser.FillObject();
if (parser.ShowUsageIfNecessary())
{
return(null);
}
return(result);
}