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);
}
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 async Task InvokeWorksFine()
{
IParseResult r = parser.Parse("Invoke1");
SuccessfulParse <InvokedTracker> ipr = Assert.IsType <SuccessfulParse <InvokedTracker> >(r);
ipr.Invoke();
Assert.True(ipr.Object.DidIGetInvoked);
ipr.Object.DidIGetInvoked = false;
await ipr.InvokeAsync();
Assert.True(ipr.Object.DidIGetInvoked);
}
public void GoodArgs_NormalResult()
{
IParseResult ipr = parser.Parse(new string[] { "OptOneOfEach", "-o", "1", "--switch", "value" });
Assert.True(ipr.Ok);
SuccessfulParse <OptOneOfEach> pr = Assert.IsType <SuccessfulParse <OptOneOfEach> >(ipr);
Assert.NotNull(pr);
Assert.NotNull(pr.Verb);
Assert.NotNull(pr.Verb);
Assert.NotNull(pr.Object);
OptOneOfEach obj = pr.Object;
Assert.Equal(1, obj.Option);
Assert.True(obj.Switch);
Assert.Equal("value", obj.Value);
}
public void GoodArgs_MultiValue()
{
IParseResult ipr = parser.Parse(new string[] { "OptMulti", "-o1", "opt1", "1", "2", "--option2", "opt2", "3" });
Assert.True(ipr.Ok);
SuccessfulParse <OptMulti> pr = Assert.IsType <SuccessfulParse <OptMulti> >(ipr);
Assert.NotNull(pr);
Assert.NotNull(pr.Verb);
Assert.NotNull(pr.Verb);
Assert.NotNull(pr.Object);
OptMulti obj = pr.Object;
Assert.Equal("opt1", obj.Option1);
Assert.Equal("opt2", obj.Option2);
Assert.Collection(obj.Values, x => Assert.Equal(1, x), x => Assert.Equal(2, x), x => Assert.Equal(3, x));
}
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));
}
}
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);
}
}
