public void StartWith_GrammarWithUnresovedRules_ThrowsException()
{
var grammar = new AdHocGrammar();
grammar.Sequence("start", grammar.Ref("item"));
grammar.Invoking(g => g.StartWith("start")).Should().Throw <GrammarException>().Where(e => e.Id == GrammarExceptionId.GrammarContainsUnresolvedRule);
}
public void Definitions_WithMinMaxVariants_GetCorrectMinMaxValues()
{
var grammar = new AdHocGrammar();
grammar.DefineRule("rule1 := 'A'{3}").ToDisplayText(DisplayMode.Definition).Should().Be("rule1 := T<'A'>{3,3}");
grammar.DefineRule("rule2 := 'A'{3,3}").ToDisplayText(DisplayMode.Definition).Should().Be("rule2 := T<'A'>{3,3}");
grammar.DefineRule("rule3 := 'A'{3,}").ToDisplayText(DisplayMode.Definition).Should().Be("rule3 := T<'A'>{3,}");
}
public void Grammar_RefAs_SetsRefNameOnRuleRef()
{
var grammar = new AdHocGrammar();
var ruleRef = grammar.Ref("test").As("handle");
ruleRef.RefName.Should().Be("handle");
((RuleRef <CstNode>)ruleRef).IsResolved.Should().BeFalse();
}
public void Grammar_ReferencingUndefinedRule_ReturnsUnresolvedRef()
{
var grammar = new AdHocGrammar();
var ruleRef = grammar.Ref("test");
ruleRef.Name.Should().BeNull();
((RuleRef <CstNode>)ruleRef).IsResolved.Should().BeFalse();
}
public void Grammar_WithoutStartRule_ThrowsExceptionOnStart()
{
var grammar = new AdHocGrammar();
grammar.TerminalType("A", "start");
grammar.Invoking(g => g.Start()).Should().Throw <GrammarException>().Where(e => e.Id == GrammarExceptionId.StartRuleNotDefined);
}
public void Grammar_RefReduceWith_SetsReducerOnRuleRef()
{
var grammar = new AdHocGrammar();
Reducer <CstNode> reducer = (IRule rule, INodeContext <CstNode> page) => EnumSequence.Of(new CstNode("Dummy", "Dummy"));
var ruleRef = grammar.Ref("test").ReduceWith(reducer);
ruleRef.Reducer.Should().Be(reducer);
((RuleRef <CstNode>)ruleRef).IsResolved.Should().BeFalse();
}
private Parser <CstNode> CreateParser(params string[] ruleDefinitions)
{
var grammar = new AdHocGrammar();
foreach (var ruleDefinition in ruleDefinitions)
{
grammar.DefineRule(ruleDefinition);
}
return(new Parser <CstNode>(grammar));
}
public void Grammar_WithStartRule_ReturnsStartRefOnStart()
{
var grammar = new AdHocGrammar();
grammar.TerminalType("A", "start");
grammar.StartWith("start");
var ruleRef = grammar.Start();
ruleRef.Should().NotBeNull();
ruleRef.RefName.Should().Be("start");
ruleRef.Name.Should().Be("start");
}
public void EvaluatingGrammar_WithMockRule_RunsMockRule()
{
var mockRule = new MockRule("mock", MockRuleBehavior.Success);
var grammar = new AdHocGrammar();
grammar.DefineRule("start", mockRule);
grammar.StartWith("start");
var lexer = StaticLexer.FromWords();
var opsMock = new RuleOperationsMock(new TokenStream(lexer).Start());
var ruleRef = grammar.Start();
var result = opsMock.Evaluate(ruleRef).Result;
result.IsSuccess.Should().BeTrue();
mockRule.DidGrab.Should().BeTrue();
result.Index.Index.Should().Be(0);
}
private static IGrammar <CstNode> SimpleGrammar()
{
var grammar = new AdHocGrammar();
// main := A choose R{2,5} .
// choose := U | V
grammar.Sequence("main",
grammar.TerminalType("A"),
grammar.Choice("choose",
grammar.TerminalValue("U"),
grammar.TerminalValue("V")
),
grammar.Repeat(null, grammar.TerminalType("R"), 2, 5),
grammar.Any(null)
);
grammar.StartWith("main");
return(grammar);
}
