public void Grab_UnresolvedRuleRef_ThrowsException()
{
var ruleRef = new RuleRef <string>();
var index = new TokenStreamIndex(new TokenStream(StaticLexer.FromWords()), 0);
ruleRef.Invoking(r => index.OperationsMock().Evaluate(r)).Should().Throw <InvalidOperationException>();
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
var operation = _operations.Call(rule, index, out result);
// accumulate step counts of called child rules
result.OnResolve += value => { stepCount += value.StepCount; };
return(operation);
}
public void InvalidRangeSpan_WithValidStream_ThrowsIndexOutOfRangeException(int start, int end)
{
var stream = CreateStream();
var span = new TokenStreamIndex(stream, start).Until(new TokenStreamIndex(stream, end));
Action action = () => span.ToList();
action.Should().Throw <IndexOutOfRangeException>();
}
public void AndANotB_GivenParseTextAndStart_BehaveCorrectlyAndInverse(string text, bool expectedSuccess)
{
var stream = new TokenStream(new CharacterLexer(text));
var index = new TokenStreamIndex(stream, 0);
var ruleAnd = CreateAndARule();
var ruleNot = CreateNotARule();
AssertLookahead(ruleAnd, index, expectedSuccess);
AssertLookahead(ruleNot, index, !expectedSuccess);
}
public void RuleRef_GrabWithRule_GrabsTargetRule()
{
var mockRule = new MockRule(nameof(MockRule));
var ruleRef = new RuleRef <string>(mockRule);
var index = new TokenStreamIndex(new TokenStream(StaticLexer.FromWords()), 0);
index.OperationsMock().Evaluate(ruleRef);
mockRule.DidGrab.Should().BeTrue();
}
private void AssertLookahead(IRule rule, TokenStreamIndex index, bool expectedSuccess)
{
var opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().Be(expectedSuccess);
opsMock.Result.Index.Index.Should().Be(0);
if (expectedSuccess && rule is And)
{
opsMock.ConcatTokens().Should().Be("A");
}
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
var state = new RuleState <TNode>(rule, index, this, _parser._ruleStack.Peek());
result = state.Result;
return(() =>
{
DebugHooks.OnBeforeCall(state, rule, index);
_parser._ruleStack.Push(state);
});
}
public void ARepeated3to5_GivenParseTextAndStart_BehavesCorrectly(string text, bool expectedSuccess, string expectedMatch)
{
var stream = new TokenStream(new CharacterLexer(text));
var index = new TokenStreamIndex(stream, 0);
var rule = CreateARepeatedRule(3, 5);
var opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().Be(expectedSuccess);
opsMock.Result.Index.Index.Should().Be(expectedSuccess ? expectedMatch.Length : 0);
opsMock.ConcatTokens().Should().Be(expectedMatch);
}
public RuleOperation Call(IRuleRef rule, TokenStreamIndex index, out CoroutineResult <RuleResult> result)
{
// Make sure that each "nested" call gets its own result
result = new CoroutineResult <RuleResult>();
_results.Push(result);
var context = new RuleContext(rule, index, this);
rule.Grab(context).ToList();
return(_noOpRuleOperation);
}
public void AbbaSequence_GivenParseTextAndStart_BehavesCorrectly(string text, int start, string expectedMatch)
{
var stream = new TokenStream(new CharacterLexer(text));
var index = new TokenStreamIndex(stream, start);
var rule = CreateAbbaRule();
var opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().Be(expectedMatch.Length == 4);
opsMock.Result.Index.Index.Should().Be(opsMock.Result.IsSuccess ? start + expectedMatch.Length : start);
opsMock.ConcatTokens().Should().Be(expectedMatch);
}
public void ARepeated_GivenArbitraryNumberOfAs_BehavesCorrectly(int count, string text)
{
var stream = new TokenStream(new CharacterLexer(text));
var index = new TokenStreamIndex(stream, 0);
var rule = CreateARepeatedRule();
var opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().BeTrue();
opsMock.Result.Index.Index.Should().Be(count);
opsMock.Tokens.Count.Should().Be(count);
opsMock.Tokens.All(t => t.Value == "A").Should().BeTrue();
}
public void AnySpan_OfTokenStream_MatchesRangeInOriginalSource()
{
var stream = CreateStream();
for (var start = 0; start < _words.Count; start++)
{
for (var end = start + 1; end < _words.Count + 1; end++)
{
var span = new TokenStreamIndex(stream, start).Until(new TokenStreamIndex(stream, end));
span.Select(t => t.Value).Should().BeEquivalentTo(_words.Skip(start).Take(end - start));
}
}
}
public void AnyTerminal_WithAnyCharacter_Succeeds(string text)
{
var stream = new TokenStream(new CharacterLexer(text));
var rule = new AnyTerminal("TEST");
TokenStreamIndex index;
RuleOperationsMock opsMock;
for (int i = 0; i < text.Length; i++)
{
index = new TokenStreamIndex(stream, i);
opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().BeTrue();
opsMock.Result.Index.Index.Should().Be(i + 1);
opsMock.ConcatTokens().Should().Be(text.Substring(i, 1));
}
index = new TokenStreamIndex(stream, text.Length);
opsMock = index.OperationsMock().Evaluate(rule);
opsMock.Result.IsSuccess.Should().BeFalse();
opsMock.Result.Index.Index.Should().Be(index.Index);
opsMock.ConcatTokens().Should().Be(String.Empty);
}
public RuleContext(IRuleRef rule, TokenStreamIndex index, IRuleOperations operations)
{
_rule = rule;
Index = index;
_operations = operations;
}
public RuleOperationsMock(TokenStreamIndex index)
{
_index = index;
}
public Task OnAfterCall(RuleState <TNode> state, IRuleRef rule, TokenStreamIndex idx, RuleResult res)
{
return(Task.CompletedTask);
}
public Task OnBeforeCall(RuleState <TNode> state, IRuleRef rule, TokenStreamIndex idx)
{
return(Task.CompletedTask);
}
public RuleOperation Success(TokenStreamIndex idx)
{
return(_operations.Complete(_rule, new RuleResult(true, idx, stepCount + 1, Index.Until(idx))));
}
public static RuleOperationsMock OperationsMock(this TokenStreamIndex index)
{
return(new RuleOperationsMock(index));
}
