public void SubVerbNotUsedWhenTheresAValue_Ok()
{
IParseResult result = new CliParserBuilder()
.AddVerb <Verb1>("verb1", verb =>
{
verb.AddOption(x => x.Option, x => x.ShortName = "-o");
verb.AddValue(x => x.Value, x =>
{
});
verb.AddVerb <Verb2>("verb2", verb2 =>
{
verb2.AddValue(x => x.Value, x =>
{
});
});
})
.Build()
.Parse(new string[] { "verb1", "-o", "value", "verb2" });
Assert.True(result.Ok);
SuccessfulParse <Verb1> pr = Assert.IsType <SuccessfulParse <Verb1> >(result);
Assert.Equal("value", pr.Object.Option);
Assert.Equal("verb2", pr.Object.Value);
}
public void AddingArguments()
{
CliParserBuilder fpb = new CliParserBuilder()
.AddVerb <OptOneOfEach>("default", verb =>
{
Option <OptOneOfEach, int> opt = verb.AddOption(x => x.Option, x =>
{
x.ShortName = "o";
x.LongName = "option";
x.HelpText = "help";
x.DescriptiveName = "name";
x.DefaultValue = 98;
});
Assert.Equal(opt, verb.AllOptions.First());
Assert.Equal("-o", opt.ShortName);
Assert.Equal("--option", opt.LongName);
Assert.Equal("help", opt.HelpText);
Assert.Equal("name", opt.DescriptiveName);
Assert.Equal(98, opt.DefaultValue);
Assert.Equal(ArgumentRequired.Optional, opt.ArgumentRequired);
Value <OptOneOfEach, string> val = verb.AddValue(x => x.Value, x =>
{
x.HelpText = "help";
x.DescriptiveName = "name";
});
Assert.Equal(val, verb.AllValues.First());
Assert.Equal("help", val.HelpText);
Assert.Equal("name", val.DescriptiveName);
Assert.Equal(default, val.DefaultValue);
public void DependencyMultipleRules()
{
CliParser fp = new CliParserBuilder()
.AddVerb <VerbVariety>("default", verb =>
{
verb.AddValue(x => x.Value, x =>
{
x.HelpText = "h";
// Optional if it's between 45 to 50, inclusive
x.HasDependency.MustNotAppearIf(e => e.OptionNullable).When(v => v > 50).WithErrorMessage("Must not be provided if OptionNullable is > 50");
x.HasDependency.RequiredIf(e => e.OptionNullable).When(v => v < 45).WithErrorMessage("Must be provided if OptionNullable is < 45");
});
verb.AddOption(x => x.OptionNullable, x => { x.ShortName = "o"; x.LongName = "option"; x.DefaultValue = null; x.HelpText = "h"; });
})
.Build();
IParseResult res = fp.Parse(new string[] { "default", "MyValue", "-o", "55" });
Assert.False(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "55" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "MyValue", "-o", "47" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "47" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "MyValue", "-o", "40" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "40" });
Assert.False(res.Ok);
}
public void ObjectValidator()
{
CliParser fp = new CliParserBuilder()
.AddVerb <OptOneOfEach>("verb", verb =>
{
verb.AddOption(x => x.Option, x => x.WithShortAndLongName("o", "opt"));
verb.ValidateObject = (obj) => obj.Option < 50 ? null : "Too much!";
})
.Build();
IParseResult pr = fp.Parse(new string[] { "verb", "-o", "10" });
Assert.IsType <SuccessfulParse <OptOneOfEach> >(pr);
Assert.True(pr.Ok);
Assert.Empty(pr.Errors);
pr = fp.Parse(new string[] { "verb", "--opt", "999" });
Assert.IsType <FailedParseWithVerb <OptOneOfEach> >(pr);
Assert.False(pr.Ok);
Assert.Equal(1, pr.Errors.Count);
var error = pr.Errors.First();
Assert.Equal(ErrorCode.ObjectFailedValidation, error.ErrorCode);
Assert.Equal("Too much!", error.Message);
}
internal static void ComplexParsing(string[] args, bool shouldBeSuccessful, ComplexVerb1?expectedResult)
{
CliParser fp = new CliParserBuilder()
.AddVerb <ComplexVerb1>("default", verb =>
{
verb.HelpText = "My Test Verb";
verb.AddValue(x => x.RequiredValue, x => x.HelpText = "h");
verb.AddValue(x => x.ConvertedValue, x => x.HelpText = "h");
verb.AddValueNullable(x => x.OptionalValue, x => { x.DefaultValue = null; x.HelpText = "h"; });
verb.AddSwitch(x => x.Switch1, x => { x.ShortName = "s1"; x.LongName = "ss1"; x.HelpText = "h"; });
verb.AddSwitch(x => x.DefaultValueSwitch, x => { x.ShortName = "s2"; x.LongName = "ss2"; x.DefaultValue = true; x.HelpText = "h"; });
verb.AddSwitchCore(a => a.ConvertedSwitch, new Arguments.Config.NamedArgConfig <ComplexVerb1, string, bool>()
{
Converter = v => Converted <string, string> .Value(v.ToString()),
HelpText = "h",
ShortName = "s3",
LongName = "ss3"
});
verb.AddSwitchCore(a => a.DefaultValueConvertedSwitch, new Arguments.Config.NamedArgConfig <ComplexVerb1, string, bool>()
{
Converter = v => Converted <string, string> .Value(v.ToString()),
DefaultValue = "Default",
HelpText = "h",
ShortName = "s4",
LongName = "ss4"
});
verb.AddOption(x => x.RequiredOption, x => { x.ShortName = "o1"; x.LongName = "oo1"; x.HelpText = "h"; });
verb.AddOption(x => x.OptionalOption, x => { x.ShortName = "o2"; x.LongName = "oo2"; x.DefaultValue = "Default"; x.HelpText = "h"; });
verb.AddOption(x => x.ConvertedOption, x => { x.ShortName = "o3"; x.LongName = "oo3"; x.HelpText = "h"; });
}).Build();
IParseResult result = fp.Parse(args);
Assert.Equal(shouldBeSuccessful, result.Ok);
if (shouldBeSuccessful)
{
SuccessfulParse <ComplexVerb1> tResult = Assert.IsType <SuccessfulParse <ComplexVerb1> >(result);
Assert.NotNull(tResult.Object);
ComplexVerb1 x = tResult.Object !;
Assert.True(expectedResult !.RequiredValue == x.RequiredValue);
Assert.True(expectedResult.ConvertedValue == x.ConvertedValue);
Assert.True(expectedResult.OptionalValue == x.OptionalValue);
Assert.True(expectedResult.Switch1 == x.Switch1);
Assert.True(expectedResult.DefaultValueSwitch == x.DefaultValueSwitch);
Assert.True(expectedResult.ConvertedSwitch == x.ConvertedSwitch);
Assert.True(expectedResult.DefaultValueConvertedSwitch == x.DefaultValueConvertedSwitch);
Assert.True(expectedResult.RequiredOption == x.RequiredOption);
Assert.True(expectedResult.OptionalOption == x.OptionalOption);
Assert.True(expectedResult.ConvertedOption == x.ConvertedOption);
}
}
public void ParsingWithInvalidVerb_Error()
{
IParseResult result = new CliParserBuilder()
.AddVerb <Verb1>("verb1", verb => { })
.Build()
.Parse(new string[] { "InvalidVerb" });
Assert.False(result.Ok);
Assert.Equal(ErrorCode.InvalidVerb, result.Errors.First().ErrorCode);
}
public void ParsingConverters_Nullable()
{
CliParser fp = new CliParserBuilder()
.AddVerb <EveryPrimitiveTypeNullable>("default", verb =>
{
verb.AddOptionNullable(x => x.Str, x => x.ShortName = "-Str");
verb.AddOption(x => x.Short, x => x.ShortName = "-Short");
verb.AddOption(x => x.UShort, x => x.ShortName = "-UShort");
verb.AddOption(x => x.Int, x => x.ShortName = "-Int");
verb.AddOption(x => x.UInt, x => x.ShortName = "-UInt");
verb.AddOption(x => x.Long, x => x.ShortName = "-Long");
verb.AddOption(x => x.ULong, x => x.ShortName = "-ULong");
verb.AddOption(x => x.Float, x => x.ShortName = "-Float");
verb.AddOption(x => x.Double, x => x.ShortName = "-Double");
verb.AddOption(x => x.Decimal, x => x.ShortName = "-Decimal");
verb.AddOption(x => x.MyEnum, x => x.ShortName = "-MyEnum");
verb.AddOption(x => x.DateTime, x => x.ShortName = "-DateTime");
verb.AddOption(x => x.TimeSpan, x => x.ShortName = "-TimeSpan");
verb.AddOption(x => x.Guid, x => x.ShortName = "-Guid");
}).Build();
IParseResult parseResult = fp.Parse(new string[]
{ "default",
"-Str", "SomeString",
"-Short", "10",
"-UShort", "20",
"-Int", "-30",
"-UInt", "40",
"-Long", "50",
"-ULong", "60",
"-Float", "70.5",
"-Double", "95.2",
"-Decimal", "100.130",
"-MyEnum", "SomeValue",
"-DateTime", "2020-10-10T05:05:05.123",
"-TimeSpan", "12:00:00",
"-Guid", "123e4567-e89b-12d3-a456-426614174000" });
EveryPrimitiveTypeNullable pr = Assert.IsType <SuccessfulParse <EveryPrimitiveTypeNullable> >(parseResult).Object;
Assert.Equal("SomeString", pr.Str);
Assert.Equal(10, pr.Short !.Value);
Assert.Equal(20, pr.UShort !.Value);
Assert.Equal(-30, pr.Int);
Assert.True(40U == pr.UInt);
Assert.Equal(50, pr.Long);
Assert.True(60UL == pr.ULong);
Assert.Equal(70.5, pr.Float !.Value);
Assert.Equal(95.2, pr.Double);
Assert.True(100.130m == pr.Decimal);
Assert.Equal(MyEnum.SomeValue, pr.MyEnum);
Assert.Equal(new DateTime(2020, 10, 10, 5, 5, 5, 123), pr.DateTime);
Assert.Equal(new TimeSpan(12, 0, 0), pr.TimeSpan);
Assert.Equal(new Guid(0x123e4567, 0xe89b, 0x12d3, 0xa4, 0x56, 0x42, 0x66, 0x14, 0x17, 0x40, 0x00), pr.Guid);
}
public void VerbParsing()
{
CliParser fp = new CliParserBuilder()
.AddVerb <Verb1>("verb1", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb2>("verb2", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb3>("verb3", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb4>("verb4", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb5>("verb5", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb6>("verb6", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb7>("verb7", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb8>("verb8", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb9>("verb9", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb10>("verb10", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb11>("verb11", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb12>("verb12", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb13>("verb13", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb14>("verb14", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb15>("verb15", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.AddVerb <Verb16>("verb16", v => v.AddValue(v => v.Value, x => x.HelpText = "h"))
.Build();
string[] args = new string[2];
int i = 1;
Check <Verb1>();
Check <Verb2>();
Check <Verb3>();
Check <Verb4>();
Check <Verb5>();
Check <Verb6>();
Check <Verb7>();
Check <Verb8>();
Check <Verb9>();
Check <Verb10>();
Check <Verb11>();
Check <Verb12>();
Check <Verb13>();
Check <Verb14>();
Check <Verb15>();
Check <Verb16>();
void Check <T>() where T : Options.Verb, new()
{
args[0] = $"verb{i}";
args[1] = "Value";
IParseResult parsed = fp.Parse(args);
Assert.NotNull(parsed.Verb);
Assert.Equal(args[0], parsed.Verb !.LongName);
i++;
}
}
public void Parse_WithDictionaryBackend_ParsesToDictionary()
{
var key = 1;
var opt = new Dictionary <int, string>();
var builder = new CliParserBuilder <Dictionary <int, string> >(opt);
builder.HasNamedArgument(c => c[key])
.WithShortName('n');
builder.Parser.Parse("-n frank".Split());
Assert.AreEqual("frank", opt[key]);
}
public void DefaultHelpSwitch_ErrorCodeHelpRequested()
{
CliParser fp = new CliParserBuilder()
.AddVerb <OptEmpty>("blah", (verb) => { }).Build();
IParseResult result1 = fp.Parse(new string[] { "-?" });
IParseResult result2 = fp.Parse("--help");
Error err = result1.Errors.Single();
Assert.Equal(ErrorCode.HelpRequested, err.ErrorCode);
Assert.Empty(err.Message);
err = result2.Errors.Single();
Assert.Equal(ErrorCode.HelpRequested, err.ErrorCode);
Assert.Empty(err.Message);
}
public void DependencyWhenShorthand()
{
CliParser fp = new CliParserBuilder()
.AddVerb <VerbVariety>("default", verb =>
{
verb.AddValue(x => x.Value, x =>
{
x.HelpText = "h"; x.HasDependency.RequiredWhen(x => x.OptionNullable > 50).WithErrorMessage("Only required if OptionNullable is larger than 50");
});
verb.AddOption(x => x.OptionNullable, x => { x.ShortName = "o"; x.LongName = "option"; x.DefaultValue = null; x.HelpText = "h"; });
})
.Build();
// We're basically saying first: MyValue is required
IParseResult res = fp.Parse(new string[] { "default", "MyValue", "-o", "55" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "55" });
Assert.False(res.Ok);
// And now we're saying MyValue is not required (So it should work either way)
res = fp.Parse(new string[] { "default", "MyValue", "-o", "30" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "30" });
Assert.True(res.Ok);
fp = new CliParserBuilder()
.AddVerb <VerbVariety>("default", verb =>
{
verb.AddValue(x => x.Value, x =>
{
x.HelpText = "h"; x.HasDependency.MustNotAppearWhen(x => x.OptionNullable > 50).WithErrorMessage("Shouldn't appear if OptionNullable is larger than 50");
});
verb.AddOption(x => x.OptionNullable, x => { x.ShortName = "o"; x.LongName = "option"; x.DefaultValue = null; x.HelpText = "h"; });
})
.Build();
// We're basically saying first: MyValue is required
res = fp.Parse(new string[] { "default", "MyValue", "-o", "55" });
Assert.False(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "55" });
Assert.True(res.Ok);
// And now we're saying MyValue is not required (So it should work either way)
res = fp.Parse(new string[] { "default", "MyValue", "-o", "30" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "30" });
Assert.True(res.Ok);
}
static void Main(string[] args)
{
CliParser parser = new CliParserBuilder()
.AddVerb <Input>("encrypt", verb =>
{
verb.HelpText = "Encrypts the input text";
verb.Invoke = EncryptText;
verb.AddValue(theClass => theClass.Text, x =>
{
x.DescriptiveName = "Input Text";
x.HelpText = "The text which has to be processed";
});
verb.AddOption(theClass => theClass.Shift, x =>
{
x.ShortName = "-s";
x.LongName = "--shift";
x.DescriptiveName = "Shift";
x.HelpText = "The number oharachters to shift";
x.Required = false;
});
})
.AddVerb <Input>("decrypt", verb =>
{
verb.HelpText = "Decrypts the input text";
verb.Invoke = DecryptText;
verb.AddValue(theClass => theClass.Text, x =>
{
x.DescriptiveName = "Input Text";
x.HelpText = "The text which has to be processed";
});
verb.AddOption(theClass => theClass.Shift, x =>
{
x.ShortName = "-s";
x.LongName = "--shift";
x.DescriptiveName = "Shift";
x.HelpText = "The number oharachters to shift";
x.Required = false;
});
})
.Build();
IParseResult result = parser.Parse(args);
parser.Handle(result);
}
public static void DictBackedConfiguration(string[] args)
{
var opt = new Dictionary <string, string>();
var builder = new CliParserBuilder <Dictionary <string, string> >(opt);
builder.HasNamedArgument(c => c["name"])
.WithShortName('n');
builder.Parser.Parse(args);
Console.WriteLine("Parsed Keys:");
foreach (var kv in opt)
{
Console.WriteLine("\t{0}: {1}", kv.Key, kv.Value);
}
}
public void DependencyNotNull()
{
CliParser fp = new CliParserBuilder()
.AddVerb <VerbVariety>("default", verb =>
{
verb.AddValue(x => x.Value, x =>
{
x.HelpText = "h"; x.HasDependency.RequiredIf(e => e.OptionNullable).IsNotNull().WithErrorMessage("If OptionNullable is not null, you must specify a value");
});
verb.AddOption(x => x.OptionNullable, x => { x.ShortName = "o"; x.LongName = "option"; x.DefaultValue = null; x.HelpText = "h"; });
})
.Build();
IParseResult res = fp.Parse(new string[] { "default", "MyValue", "-o", "30" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "30" });
Assert.False(res.Ok);
res = fp.Parse(new string[] { "default", "MyValue" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default" });
Assert.True(res.Ok);
fp = new CliParserBuilder()
.AddVerb <VerbVariety>("default", verb =>
{
verb.AddValue(x => x.Value, x =>
{
x.HelpText = "h"; x.HasDependency.MustNotAppearIf(e => e.OptionNullable).IsNotNull().WithErrorMessage("If OptionNullable is not null, you must NOT specify a value");
});
verb.AddOption(x => x.OptionNullable, x => { x.ShortName = "o"; x.LongName = "option"; x.DefaultValue = null; x.HelpText = "h"; });
})
.Build();
res = fp.Parse(new string[] { "default", "MyValue", "-o", "30" });
Assert.False(res.Ok);
res = fp.Parse(new string[] { "default", "-o", "30" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default", "MyValue" });
Assert.True(res.Ok);
res = fp.Parse(new string[] { "default" });
Assert.True(res.Ok);
}
public static void DictBackendMethodConfig(string[] args)
{
const int key = 1;
var opt = new Dictionary <int, object>();
var builder = new CliParserBuilder <Dictionary <int, object> >(opt);
builder.HasNamedArgument(c => c[key])
.WithShortName('n');
builder.Parser.Parse(args);
Console.WriteLine("Parsed Keys:");
foreach (var kv in opt)
{
Console.WriteLine("\t{0}: {1}", kv.Key, kv.Value);
}
}
public void ParsingSubVerb_Ok()
{
IParseResult result = new CliParserBuilder()
.AddVerb("verb1", verb =>
{
verb.AddVerb <Verb2>("verb2", verb2 =>
{
verb2.AddValue(x => x.Value, x =>
{
});
});
})
.Build()
.Parse(new string[] { "verb1", "verb2", "value" });
Assert.True(result.Ok);
SuccessfulParse <Verb2> pr = Assert.IsType <SuccessfulParse <Verb2> >(result);
Assert.Equal("value", pr.Object.Value);
}
internal static void ManyValueParsing(string[] args, bool shouldBeSuccessful, OptOneOfEach expectedResult)
{
CliParser fp = new CliParserBuilder()
.AddVerb <OptOneOfEach>("default", verb =>
{
verb.AddMultiValue(x => x.ManyValues, x => x.HelpText = "h");
verb.AddOption(x => x.Option, x => { x.ShortName = "o"; x.LongName = "oo"; x.DefaultValue = 0; x.HelpText = "h"; });
verb.AddSwitch(x => x.Switch, x => { x.ShortName = "s"; x.LongName = "ss"; x.HelpText = "h"; });
}).Build();
IParseResult result = fp.Parse(args);
Assert.Equal(shouldBeSuccessful, result.Ok);
if (shouldBeSuccessful)
{
SuccessfulParse <OptOneOfEach> tResult = Assert.IsType <SuccessfulParse <OptOneOfEach> >(result);
OptOneOfEach x = tResult.Object !;
Assert.NotNull(x);
Assert.True(expectedResult.Option == x.Option);
Assert.True(expectedResult.Switch == x.Switch);
Assert.True(expectedResult.ManyValues.SequenceEqual(x.ManyValues));
}
}
public static void FluentConditional(string destinationFromConfig, string[] args)
{
var opt = new ConditionalOptions();
var builder = new CliParserBuilder <ConditionalOptions>(opt);
switch (destinationFromConfig)
{
case "file":
builder.HasNamedArgument(c => c.Filename)
.WithShortName('f');
break;
//case "http":
default:
builder.HasNamedArgument(c => c.Url)
.WithShortName('u');
break;
}
builder.Parser.Parse(args);
Console.WriteLine("Filename: {0}", opt.Filename);
Console.WriteLine("Url: {0}", opt.Url);
}
internal Positional(CliParserBuilder <TConf> parser, IValueStoreDefinition store)
: base(parser, store)
{
}
internal NamedList(CliParserBuilder <TConfig> parser, IValueStoreDefinition store)
: base(parser, store)
{
Consumes = new Consumes <TConfig, NamedBase <TConfig, NamedList <TConfig, TArg>, TArg>, TArg>(this);
}
internal Named(CliParserBuilder <TConfig> parser, IValueStoreDefinition store)
: base(parser, store)
{
}
public void Parse_WithDictionaryBackend_ParsesToDictionary()
{
var key = 1;
var opt = new Dictionary<int, string>();
var builder = new CliParserBuilder<Dictionary<int, string>>(opt);
builder.HasNamedArgument(c => c[key])
.WithShortName('n');
builder.Parser.Parse("-n frank".Split());
Assert.AreEqual("frank", opt[key]);
}
internal Verb(CliParserBuilder <TConf> parser)
{
And = parser;
}
public PositionalList(CliParserBuilder <TConfig> parser, IValueStoreDefinition store)
: base(parser, store)
{
Consumes = new Consumes <TConfig, PositionalList <TConfig, TArg>, TArg>(this);
}
protected ArgumentBase(CliParserBuilder <TConfig> parser)
{
And = parser;
}
protected NamedBase(CliParserBuilder <TConfig> parser, IValueStoreDefinition store)
: base(parser)
{
Arg = new NamedArgument(store);
HasDefaultName = false;
}
public void ManyValueAccumulators()
{
CliParser fp = new CliParserBuilder().AddVerb <OptArray>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptArray = Assert.IsType <SuccessfulParse <OptArray> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptArray.Collection);
Assert.Contains("String2", objOptArray.Collection);
Assert.Contains("String3", objOptArray.Collection);
fp = new CliParserBuilder().AddVerb <OptList>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptList = Assert.IsType <SuccessfulParse <OptList> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptList.Collection);
Assert.Contains("String2", objOptList.Collection);
Assert.Contains("String3", objOptList.Collection);
fp = new CliParserBuilder().AddVerb <OptIList>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptIList = Assert.IsType <SuccessfulParse <OptIList> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptIList.Collection);
Assert.Contains("String2", objOptIList.Collection);
Assert.Contains("String3", objOptIList.Collection);
fp = new CliParserBuilder().AddVerb <OptIReadOnlyList>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptIReadOnlyList = Assert.IsType <SuccessfulParse <OptIReadOnlyList> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptIReadOnlyList.Collection);
Assert.Contains("String2", objOptIReadOnlyList.Collection);
Assert.Contains("String3", objOptIReadOnlyList.Collection);
fp = new CliParserBuilder().AddVerb <OptICollection>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptICollection = Assert.IsType <SuccessfulParse <OptICollection> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptICollection.Collection);
Assert.Contains("String2", objOptICollection.Collection);
Assert.Contains("String3", objOptICollection.Collection);
fp = new CliParserBuilder().AddVerb <OptIReadOnlyCollection>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptIReadOnlyCollection = Assert.IsType <SuccessfulParse <OptIReadOnlyCollection> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptIReadOnlyCollection.Collection);
Assert.Contains("String2", objOptIReadOnlyCollection.Collection);
Assert.Contains("String3", objOptIReadOnlyCollection.Collection);
fp = new CliParserBuilder().AddVerb <OptIEnumerable>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptIEnumerable = Assert.IsType <SuccessfulParse <OptIEnumerable> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptIEnumerable.Collection);
Assert.Contains("String2", objOptIEnumerable.Collection);
Assert.Contains("String3", objOptIEnumerable.Collection);
fp = new CliParserBuilder().AddVerb <OptHashSet>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptHashSet = Assert.IsType <SuccessfulParse <OptHashSet> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptHashSet.Collection);
Assert.Contains("String2", objOptHashSet.Collection);
Assert.Contains("String3", objOptHashSet.Collection);
fp = new CliParserBuilder().AddVerb <OptStack>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptStack = Assert.IsType <SuccessfulParse <OptStack> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptStack.Collection);
Assert.Contains("String2", objOptStack.Collection);
Assert.Contains("String3", objOptStack.Collection);
fp = new CliParserBuilder().AddVerb <OptQueue>("default", verb => verb.AddMultiValue(x => x.Collection, x => { })).Build();
var objOptQueue = Assert.IsType <SuccessfulParse <OptQueue> >(fp.Parse(new string[] { "default", "String1", "String2", "String3" })).Object;
Assert.Contains("String1", objOptQueue.Collection);
Assert.Contains("String2", objOptQueue.Collection);
Assert.Contains("String3", objOptQueue.Collection);
}
internal static void SimpleParsing(bool outcome, bool isValidVerb, Components components, string[] args)
{
CliParser fp = new CliParserBuilder()
.AddVerb <OptOneOfEach>("default", verb =>
{
if ((components & Components.Value) == Components.Value)
{
verb.AddValue(x => x.Value, x => x.HelpText = "h");
}
if ((components & Components.Switch) == Components.Switch)
{
verb.AddSwitch(x => x.Switch, x => { x.ShortName = "-s"; x.LongName = "--switch"; x.HelpText = "h"; });
}
if ((components & Components.Option) == Components.Option)
{
verb.AddOption(x => x.Option, x => { x.ShortName = "-o"; x.LongName = "--option"; x.HelpText = "h"; });
}
}).Build();
IParseResult parsed = fp.Parse(args);
if (outcome)
{
Assert.True(parsed.Ok);
SuccessfulParse <OptOneOfEach> parseResult = Assert.IsType <SuccessfulParse <OptOneOfEach> >(parsed);
Assert.NotNull(parseResult.Object);
OptOneOfEach parsedObject = parseResult.Object !;
Assert.NotNull(parsedObject);
if ((components & Components.Value) == Components.Value)
{
Assert.Equal("Value", parsedObject.Value);
}
if ((components & Components.Switch) == Components.Switch)
{
Assert.True(parsedObject.Switch, $"Switch was specified but didn't set property to true");
}
else
{
Assert.False(parsedObject.Switch, $"Switch was specified but didn't set property to false");
}
if ((components & Components.Option) == Components.Option)
{
Assert.Equal(30, parsedObject.Option);
}
}
else
{
Assert.False(parsed.Ok);
// Verb still shouldn't be null, since for our test cases we DO pass the verb
if (isValidVerb)
{
Assert.NotNull(parsed.Verb);
}
else
{
Assert.Null(parsed.Verb);
}
Assert.NotEmpty(parsed.Errors);
}
}
protected PositionalBase(CliParserBuilder <TConfig> parser, IValueStoreDefinition store)
: base(parser)
{
Arg = Arg = new PositionalArgument(store);
}
