private static void TestGrammarParser()
{
string productionRule = "clauses : clause (COMMA [D] clause)*";
var ruleparser = new RuleParser <TestGrammarToken>();
var builder = new ParserBuilder <EbnfTokenGeneric, GrammarNode <TestGrammarToken> >();
var grammarParser = builder.BuildParser(ruleparser, ParserType.LL_RECURSIVE_DESCENT, "rule").Result;
var result = grammarParser.Parse(productionRule);
//(grammarParser.Lexer as GenericLexer<TestGrammarToken>).ResetLexer();
Console.WriteLine($"alors ? {string.Join('\n',result.Errors.Select(e => e.ErrorMessage))}");
result = grammarParser.Parse(productionRule);
Console.WriteLine($"alors ? {string.Join('\n',result.Errors.Select(e => e.ErrorMessage))}");
;
Console.WriteLine("starting");
ErroneousGrammar parserInstance = new ErroneousGrammar();
Console.WriteLine("new instance");
var builder2 = new ParserBuilder <TestGrammarToken, object>();
Console.WriteLine("builder");
var Parser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "rule");
Console.WriteLine($"built : {Parser.IsOk}");
}
public void TestIssue184()
{
StartingRule = $"{typeof(Issue184ParserOne).Name}_expressions";
var parserInstance = new Issue184ParserOne();
var builder = new ParserBuilder <Issue184Token, double>();
var issue184parser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);
Assert.True(issue184parser.IsOk);
var c = issue184parser.Result.Parse(" 2 + 2");
Assert.True(c.IsOk);
Assert.Equal(4.0, c.Result);
StartingRule = $"{typeof(Issue184Parser).Name}_expressions";
var parserInstance2 = new Issue184Parser();
var builder2 = new ParserBuilder <Issue184Token, double>();
var issue184parser2 = builder.BuildParser(parserInstance2, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);
Assert.True(issue184parser2.IsOk);
var c2 = issue184parser2.Result.Parse(" 2 + 2");
Assert.True(c2.IsOk);
Assert.Equal(4.0, c2.Result);
c2 = issue184parser2.Result.Parse(" 2 + 2 / 2");
Assert.True(c2.IsOk);
Assert.Equal(2 + 2 / 2, c2.Result);
c2 = issue184parser2.Result.Parse(" 2 - 2 * 2");
Assert.True(c2.IsOk);
Assert.Equal(2 - 2 * 2, c2.Result);
}
public SearchQueryParser(ILogger <SearchQueryParser> logger)
{
this.logger = logger;
//Sly isn't designed with DI in mind, so... just hide it inside our own
//dependency injection interface thing. Doesn't matter that we're directly instantiating it
parserInstance = new QueryExpressionParser();
var builder = new ParserBuilder <QueryToken, string>();
var buildResult = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "expr");
if (buildResult.IsError)
{
var errors = buildResult.Errors?.Select(x => x.Message);
if (errors == null || errors.Count() == 0)
{
errors = new List <string> {
"Unknown error"
}
}
;
throw new InvalidOperationException("Couldn't construct parser: " + string.Join(",", errors));
}
parser = buildResult.Result;
}
protected ParsingResult CallParse(ParserBuilder parserBuilder, IEnumerable <string> args)
{
var parser = parserBuilder.BuildParser();
var parsingResult = parser.Parse(args, _scopedServiceProvider);
return(parsingResult);
}
public void PreRunTest()
{
var parserInstance = new FormulaParser();
var builder = new ParserBuilder <FormulaToken, IFormula>();
var parserResult = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "formulae");
Assert.True(parserResult.IsOk);
var source = @"
aaa = bbb + 1
bbb = ccc + 2
ccc = 3 + 3
";
var t = parserResult.Result.Parse(source);
Assert.True(t.IsOk);
var form = t.Result as Formulae;
var depbuilder = new Dependencies();
bool isCyclic = depbuilder.Build(t.Result as Formulae);
Assert.False(isCyclic);
var checker = new TypeChecker();
checker.Type(form, depbuilder.DependenciesDictionary);
}
public static void TestScript()
{
var parserInstance = new ScriptParser();
var builder = new ParserBuilder <ScriptToken, object>();
var parserBuild = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "test");
if (parserBuild.IsOk)
{
var parser = parserBuild.Result;
string ko1 = "|B|test2(a, b, c=100)|E|";
string ko2 = "|B|plotshape(data, style=shapexcross)|E|";
var r = parser.Parse(ko1);
var graphviz = new GraphVizEBNFSyntaxTreeVisitor <ScriptToken>();
var root = graphviz.VisitTree(r.SyntaxTree);
var graph = graphviz.Graph.Compile();
r = parser.Parse(ko2);
}
else
{
foreach (var e in parserBuild.Errors)
{
Console.WriteLine(e.Level + " - " + e.Message);
}
}
}
public JsonTests()
{
var jsonParser = new JSONParser();
var builder = new ParserBuilder <JsonToken, JSon>();
Parser = builder.BuildParser(jsonParser, ParserType.LL_RECURSIVE_DESCENT, "root").Result;
}
private static Expression Parse(string query)
{
var parserInstance = new EarlyEosParser();
var builder = new ParserBuilder <EarlyEosToken, Expression>();
var buildResult =
builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "expression");
if (buildResult.IsError)
{
throw new AggregateException(
buildResult.Errors
.Select(e => new Exception($"{e.Level} {e.Code} {e.Message}"))
);
}
var parser = buildResult.Result;
var queryExpression = parser.Parse(query.Trim());
var graphviz = new GraphVizEBNFSyntaxTreeVisitor <EarlyEosToken>();
var root = graphviz.VisitTree(queryExpression.SyntaxTree);
string graph = graphviz.Graph.Compile();
;
if (queryExpression.IsError)
{
throw new AggregateException(
queryExpression.Errors
.Select(e => new Exception(e.ErrorMessage))
);
}
return(queryExpression.Result);
}
public void ParseWithValidArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable <string> args = new[] { "delete", "-Source:custom value", "-np", "-ApiKey", "MyApiKey", "Custom argument value", "b" };
var expectedReturnCode = CommandResultCode.Ok;
var expectedSource = "custom value";
var expectedApiKey = "MyApiKey";
var expectedNbOfArguments = 2;
var expectedArgumentsValue = new List <string> {
"Custom argument value", "b"
};
// Act
var actual = parser.Parse(args);
// Assert
Assert.True(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.IsType <DeleteCommand>(actual.Command);
Assert.Equal(expectedSource, ((DeleteCommand)actual.Command).Source);
Assert.Equal(expectedApiKey, ((DeleteCommand)actual.Command).ApiKey);
Assert.True(((DeleteCommand)actual.Command).NoPrompt);
Assert.Null(((DeleteCommand)actual.Command).SourceProvider);
Assert.Null(((DeleteCommand)actual.Command).Settings);
Assert.Equal(expectedNbOfArguments, ((DeleteCommand)actual.Command).Arguments.Count);
for (var i = 0; i < expectedNbOfArguments; i++)
{
Assert.Equal(expectedArgumentsValue[i], actual.Command.Arguments[i]);
}
}
public static void testJSON()
{
try {
var instance = new EbnfJsonGenericParser();
var builder = new ParserBuilder <JsonTokenGeneric, JSon>();
var buildResult = builder.BuildParser(instance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "root");
// if (buildResult.IsOk)
// {
// Console.WriteLine("parser built.");
// var parser = buildResult.Result;
// var content = File.ReadAllText("test.json");
// Console.WriteLine("test.json read.");
// var jsonResult = parser.Parse(content);
// Console.WriteLine("json parse done.");
// if (jsonResult.IsOk)
// {
// Console.WriteLine("YES !");
// }
// else
// {
// Console.WriteLine("Ooh no !");
// }
// Console.WriteLine("Done.");
//
// }
// else
// {
// buildResult.Errors.ForEach(e => Console.WriteLine(e.Message));
// }
}
catch (Exception e) {
Console.WriteLine($"ERROR {e.Message} : \n {e.StackTrace}");
}
}
private static void testJSONLexer()
{
var builder = new ParserBuilder <JsonToken, JSon>();
var parser = builder.BuildParser(new JSONParser(), ParserType.EBNF_LL_RECURSIVE_DESCENT, "root");
var source = "{ \"k\" : 1;\"k2\" : 1.1;\"k3\" : null;\"k4\" : false}";
//source = File.ReadAllText("test.json");
var lexer = new JSONLexer();
var sw = new Stopwatch();
sw.Start();
var lexresult = lexer.Tokenize(source);
if (lexresult.IsOk)
{
var tokens = lexresult.Tokens;
sw.Stop();
Console.WriteLine($"hard coded lexer {tokens.Count()} tokens in {sw.ElapsedMilliseconds}ms");
var sw2 = new Stopwatch();
var start = DateTime.Now.Millisecond;
sw2.Start();
lexresult = parser.Result.Lexer.Tokenize(source);
if (lexresult.IsOk)
{
tokens = lexresult.Tokens;
sw2.Stop();
var end = DateTime.Now.Millisecond;
Console.WriteLine(
$"old lexer {tokens.Count()} tokens in {sw2.ElapsedMilliseconds}ms / {end - start}ms");
}
}
}
public void Setup()
{
Console.WriteLine(("SETUP"));
Console.ReadLine();
content = File.ReadAllText("test.json");
Console.WriteLine("json read.");
var jsonParser = new EbnfJsonGenericParser();
var builder = new ParserBuilder <JsonTokenGeneric, JSon>();
var result = builder.BuildParser(jsonParser, ParserType.EBNF_LL_RECURSIVE_DESCENT, "root");
Console.WriteLine("parser built.");
if (result.IsError)
{
Console.WriteLine("ERROR");
result.Errors.ForEach(e => Console.WriteLine(e));
}
else
{
Console.WriteLine("parser ok");
BenchedParser = result.Result;
}
Console.WriteLine($"parser {BenchedParser}");
}
private static Expression Parse(string query)
{
var parserInstance = new IndexOutOfRangeParser();
var builder = new ParserBuilder <IndexOutOfRangeToken, Expression>();
var buildResult =
builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "expression");
// if (buildResult.IsError)
// throw new AggregateException(
// buildResult.Errors
// .Select(e => new Exception($"{e.Level} {e.Code} {e.Message}"))
// );
var parser = buildResult.Result;
var queryExpression = parser.Parse(query.Trim());
if (queryExpression.IsError)
{
throw new AggregateException(
queryExpression.Errors
.Select(e => new Exception(e.ErrorMessage))
);
}
return(queryExpression.Result);
}
private static void TestFactorial()
{
var whileParser = new WhileParser();
var builder = new ParserBuilder <WhileToken, WhileAST>();
var Parser = builder.BuildParser(whileParser, ParserType.EBNF_LL_RECURSIVE_DESCENT, "statement");
;
var program = @"
(
r:=1;
i:=1;
while i < 11 do
(";
program += "\nprint \"r=\".r;\n";
program += "r := r * i;\n";
program += "print \"r=\".r;\n";
program += "print \"i=\".i;\n";
program += "i := i + 1 \n);\n";
program += "return r)\n";
var result = Parser.Result.Parse(program);
var interpreter = new Interpreter();
var context = interpreter.Interprete(result.Result);
var compiler = new WhileCompiler();
var code = compiler.TranspileToCSharp(program);
var f = compiler.CompileToFunction(program);
;
}
public ExpressionTests()
{
ExpressionParser parserInstance = new ExpressionParser();
ParserBuilder <ExpressionToken, int> builder = new ParserBuilder <ExpressionToken, int>();
Parser = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "expression").Result;
}
public void ParseWithValidListArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = new[]
{"IntTest", "-Strvalue:custom value", "-i", "42", "-il", "42", "Custom argument value", "-b"};
var expectedReturnCode = CommandResultCode.Ok;
var expectedStrValue = "custom value";
var expectedNbOfArguments = 1;
var expectedArgumentsValue = "Custom argument value";
var expectedIntValue = 42;
// Act
var actual = parser.Parse(args);
// Assert
Assert.True(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.IsType<IntTestCommand>(actual.Command);
Assert.Equal(expectedStrValue, ((IntTestCommand) actual.Command).StrValue);
Assert.Equal(expectedIntValue, ((IntTestCommand) actual.Command).IntValue);
Assert.NotNull(((IntTestCommand) actual.Command).IntListValue);
Assert.Equal(expectedNbOfArguments, ((IntTestCommand) actual.Command).Arguments.Count);
Assert.Equal(expectedArgumentsValue, ((IntTestCommand) actual.Command).Arguments.Single());
Assert.Equal(expectedNbOfArguments, ((IntTestCommand) actual.Command).IntListValue.Count);
Assert.Equal(expectedIntValue, ((IntTestCommand) actual.Command).IntListValue.Single());
Assert.True(((IntTestCommand) actual.Command).BoolValue);
}
public void TestIssue213()
{
var parserInstance = new DoNotIgnoreCommentsParser();
var builder = new ParserBuilder <DoNotIgnoreCommentsToken, DoNotIgnore>();
var builtParser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "main");
Assert.True(builtParser.IsOk);
Assert.NotNull(builtParser.Result);
var parser = builtParser.Result;
var test = parser.Parse("a /*commented b*/b");
Assert.True(test.IsOk);
Assert.NotNull(test.Result);
Assert.IsType <IdentifierList>(test.Result);
var list = test.Result as IdentifierList;
Assert.Equal(2, list.Ids.Count);
Assert.False(list.Ids[0].IsCommented);
Assert.Equal("a", list.Ids[0].Name);
Assert.True(list.Ids[1].IsCommented);
Assert.Equal("b", list.Ids[1].Name);
Assert.Equal("commented b", list.Ids[1].Comment);
;
}
public void ParseWithValidListArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable <string> args = new[]
{ "-Strvalue:custom value", "-i", "42", "-il", "42", "Custom argument value", "-b" };
var expectedReturnCode = CommandResultCode.Ok;
var expectedStrValue = "custom value";
var expectedNbOfArguments = 1;
var expectedArgumentsValue = "Custom argument value";
var expectedIntValue = 42;
// Act
var actual = parser.Parse <IntTestCommand>(args);
// Assert
Assert.True(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.IsType <IntTestCommand>(actual.Command);
Assert.Equal(expectedStrValue, (actual.Command).StrValue);
Assert.Equal(expectedIntValue, (actual.Command).IntValue);
Assert.NotNull(actual.Command.IntListValue);
Assert.Equal(expectedNbOfArguments, actual.Command.Arguments.Count);
Assert.Equal(expectedArgumentsValue, actual.Command.Arguments.Single());
Assert.Equal(expectedNbOfArguments, actual.Command.IntListValue.Count);
Assert.Equal(expectedIntValue, actual.Command.IntListValue.Single());
Assert.True(actual.Command.BoolValue);
}
public VariableExpressionTests()
{
var parserInstance = new VariableExpressionParser();
var builder = new ParserBuilder <ExpressionToken, Expression>();
Parser = builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, "expression").Result;
}
public JsonGenericTests()
{
var jsonParser = new EbnfJsonGenericParser();
var builder = new ParserBuilder <JsonTokenGeneric, JSon>();
Parser = builder.BuildParser(jsonParser, ParserType.EBNF_LL_RECURSIVE_DESCENT, "root").Result;
}
public void ParseWithValidArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = new[] { "delete", "-Source:custom value", "-np", "-ApiKey", "MyApiKey", "Custom argument value", "b" };
var expectedReturnCode = CommandResultCode.Ok;
var expectedSource = "custom value";
var expectedApiKey = "MyApiKey";
var expectedNbOfArguments = 2;
var expectedArgumentsValue = new List<string> { "Custom argument value", "b" };
// Act
var actual = parser.Parse(args);
// Assert
Assert.True(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.IsType<DeleteCommand>(actual.Command);
Assert.Equal(expectedSource, ((DeleteCommand)actual.Command).Source);
Assert.Equal(expectedApiKey, ((DeleteCommand)actual.Command).ApiKey);
Assert.True(((DeleteCommand)actual.Command).NoPrompt);
Assert.Null(((DeleteCommand)actual.Command).SourceProvider);
Assert.Null(((DeleteCommand)actual.Command).Settings);
Assert.Equal(expectedNbOfArguments, ((DeleteCommand)actual.Command).Arguments.Count);
for (var i = 0; i < expectedNbOfArguments; i++)
{
Assert.Equal(expectedArgumentsValue[i], actual.Command.Arguments[i]);
}
}
public void TestBug100()
{
var startingRule = $"testNonTerm";
var parserInstance = new Bugfix100Test();
var builder = new ParserBuilder <GroupTestToken, int>();
var builtParser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, startingRule);
Assert.False(builtParser.IsError);
Assert.NotNull(builtParser.Result);
var parser = builtParser.Result;
Assert.NotNull(parser);
var conf = parser.Configuration;
var expected = new List <GroupTestToken>()
{
GroupTestToken.A, GroupTestToken.COMMA
};
var nonTerm = conf.NonTerminals["testNonTerm"];
Assert.NotNull(nonTerm);
Assert.Equal(2, nonTerm.PossibleLeadingTokens.Count);
Assert.True(nonTerm.PossibleLeadingTokens.ContainsAll(expected));
var term = conf.NonTerminals["testTerm"];
Assert.NotNull(term);
Assert.Equal(2, nonTerm.PossibleLeadingTokens.Count);
Assert.True(term.PossibleLeadingTokens.ContainsAll(expected));
}
private ILexer <ExpressionToken> GetExpressionLexer()
{
var exprParser = new ExpressionParser();
var builder = new ParserBuilder <ExpressionToken, int>();
var parser = builder.BuildParser(exprParser, ParserType.LL_RECURSIVE_DESCENT, "expression").Result;
return(parser.Lexer);
}
private ILexer <JsonToken> GetJsonLexer()
{
var jsonParser = new JSONParser();
var builder = new ParserBuilder <JsonToken, JSon>();
var parser = builder.BuildParser(jsonParser, ParserType.LL_RECURSIVE_DESCENT, "root").Result;
return(parser.Lexer);
}
public void BuildParserTest()
{
var parserInstance = new FormulaParser();
var builder = new ParserBuilder <FormulaToken, IFormula>();
var parserResult = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "formulae");
Assert.True(parserResult.IsOk);
}
private void BuildParser()
{
StartingRule = $"{typeof(SimpleExpressionParser).Name}_expressions";
var parserInstance = new SimpleExpressionParser();
var builder = new ParserBuilder <ExpressionToken, double>();
Parser = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, StartingRule);
}
private BuildResult <Parser <TokenType, string> > BuildParser()
{
var parserInstance = new EBNFTests();
var builder = new ParserBuilder <TokenType, string>();
var result = builder.BuildParser(parserInstance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "R");
return(result);
}
protected ParsingResult CallParseWithDefaultCommand <TCommand>(ParserBuilder parserBuilder, IEnumerable <string> args)
where TCommand : class, ICommand
{
var parser = parserBuilder.BuildParser();
var parsingResult = parser.ParseWithDefaultCommand <TCommand>(args, _scopedServiceProvider);
return(parsingResult);
}
public void TestBadVisitorTerminalArgument()
{
var instance = new BadTerminalArgParser();
ParserBuilder <BadVisitorTokens, BadVisitor> builder = new ParserBuilder <BadVisitorTokens, BadVisitor>();
var result = builder.BuildParser(instance, ParserType.LL_RECURSIVE_DESCENT, "badtermarg");
Assert.True(result.IsError);
Assert.Single(result.Errors);
//"visitor BadReturn for rule badtermarg : A B ; parameter a has incorrect type : expected sly.lexer.Token`1[ParserTests.BadVisitorTokens], found SubBadVisitor"
Assert.Contains("parameter aArg has incorrect type", result.Errors.First().Message);
result = builder.BuildParser(instance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "badtermarg");
Assert.True(result.IsError);
Assert.Single(result.Errors);
//"visitor BadReturn for rule badtermarg : A B ; parameter a has incorrect type : expected sly.lexer.Token`1[ParserTests.BadVisitorTokens], found SubBadVisitor"
Assert.Contains("parameter aArg has incorrect type", result.Errors.First().Message);
}
private static BuildResult <Parser <ExpressionToken, double> > BuildParserExpression()
{
var StartingRule = $"{typeof(SimpleExpressionParser).Name}_expressions";
var parserInstance = new SimpleExpressionParser();
var builder = new ParserBuilder <ExpressionToken, double>();
return(builder.BuildParser(parserInstance, ParserType.LL_RECURSIVE_DESCENT, StartingRule));
}
public WhileCompiler()
{
var parser = new WhileParser();
var builder = new ParserBuilder <WhileToken, WhileAST>();
var whileParserBuildResult = builder.BuildParser(parser, ParserType.EBNF_LL_RECURSIVE_DESCENT, "statement");
whileParser = whileParserBuildResult.Result;
}
public void TestBadVisitorReturn()
{
var instance = new BadVisitorReturnParser();
ParserBuilder <BadVisitorTokens, BadVisitor> builder = new ParserBuilder <BadVisitorTokens, BadVisitor>();
var result = builder.BuildParser(instance, ParserType.LL_RECURSIVE_DESCENT, "badreturn");
Assert.True(result.IsError);
Assert.Single(result.Errors);
Assert.Contains("incorrect return type", result.Errors.First().Message);
Assert.Contains("visitor BadReturn", result.Errors.First().Message);
result = builder.BuildParser(instance, ParserType.EBNF_LL_RECURSIVE_DESCENT, "badreturn");
Assert.True(result.IsError);
Assert.Single(result.Errors);
Assert.Contains("incorrect return type", result.Errors.First().Message);
Assert.Contains("visitor BadReturn", result.Errors.First().Message);
;
}
public void ParseWithInValidArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = new[] { "delete", "-Source:custom value", "-pn", "ApiKey", "MyApiKey", "Custom argument value", "b" };
var expectedMessageException = @"There is no option 'pn' for the command 'Delete'.";
// Act
var actual = Assert.Throws<CommandLineParserException>(() => parser.Parse(args));
// Assert
Assert.Equal(expectedMessageException, actual.Message);
}
public void ParseWithBadCommandName()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = new[] { "NotValid", "-option:true" };
var expectedReturnCode = CommandResultCode.NoCommandFound;
// Act
var actual = parser.Parse(args);
// Assert
Assert.False(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.Null(actual.Command);
}
public void ParseWithoutParameter()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = null;
var expectedReturnCode = CommandResultCode.NoArgs;
// Act
var actual = parser.Parse(args);
// Assert
Assert.False(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.Null(actual.Command);
}
public void ParseWithInvalidArgs()
{
// Arrange
var parserBuild = new ParserBuilder();
var parser = parserBuild.BuildParser();
IEnumerable<string> args = new[] {"-i", "42", "Custom argument value", "-b"};
var expectedReturnCode = CommandResultCode.CommandParameterNotValid;
var expectedNbOfArguments = 1;
var expectedArgumentsValue = "Custom argument value";
var expectedIntValue = 42;
// Act
var actual = parser.Parse<IntTestCommand>(args);
// Assert
Assert.False(actual.IsValid);
Assert.Equal(expectedReturnCode, actual.ReturnCode);
Assert.IsType<IntTestCommand>(actual.Command);
Assert.Equal(expectedIntValue, actual.Command.IntValue);
Assert.Null(actual.Command.IntListValue);
Assert.Equal(expectedNbOfArguments, actual.Command.Arguments.Count);
Assert.Equal(expectedArgumentsValue, actual.Command.Arguments.Single());
Assert.True(actual.Command.BoolValue);
}