public void OmitsUnknownErrorsWhenAdditionalErrorsExist()
{
FailureMessages.Empty
.With(FailureMessage.Expected("A"))
.With(FailureMessage.Expected("B"))
.With(FailureMessage.Unknown())
.With(FailureMessage.Expected("C"))
.ToString().ShouldBe("A, B or C expected");
}
public void OmitsDuplicateExpectationsFromExpectationLists()
{
FailureMessages.Empty
.With(FailureMessage.Expected("A"))
.With(FailureMessage.Expected("A"))
.With(FailureMessage.Expected("B"))
.With(FailureMessage.Expected("C"))
.With(FailureMessage.Unknown())
.With(FailureMessage.Expected("C"))
.With(FailureMessage.Expected("C"))
.With(FailureMessage.Expected("A"))
.ToString().ShouldBe("A, B or C expected");
}
public void CanMergeTwoLists()
{
var first = FailureMessages.Empty
.With(FailureMessage.Expected("A"))
.With(FailureMessage.Expected("B"))
.With(FailureMessage.Unknown())
.With(FailureMessage.Expected("C"));
var second = FailureMessages.Empty
.With(FailureMessage.Expected("D"))
.With(FailureMessage.Expected("B"))
.With(FailureMessage.Unknown())
.With(FailureMessage.Expected("E"));
first.Merge(second)
.ToString().ShouldBe("A, B, C, D or E expected");
}
private IReply <TValue> Parse(TokenStream tokens, int precedence)
{
var token = tokens.Current;
if (!_unitParsers.ContainsKey(token.Kind))
{
return(new Failure <TValue>(tokens, FailureMessage.Unknown()));
}
var reply = _unitParsers[token.Kind].Parse(tokens);
if (!reply.Success)
{
return(reply);
}
tokens = reply.UnparsedTokens;
token = tokens.Current;
while (precedence < GetPrecedence(token))
{
//Continue parsing at this precedence level.
reply = _extendParsers[token.Kind](reply.ParsedValue).Parse(tokens);
if (!reply.Success)
{
return(reply);
}
tokens = reply.UnparsedTokens;
token = tokens.Current;
}
return(reply);
}
public void CreatesParsersFromLambdas()
{
var succeeds = new LambdaParser <string>(tokens => new Success <string>("AA", tokens.Advance().Advance()));
succeeds.PartiallyParses(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("B", "B").WithValue("AA");
var fails = new LambdaParser <string>(tokens => new Failure <string>(tokens, FailureMessage.Unknown()));
fails.FailsToParse(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("A", "A", "B", "B").WithMessage("(1, 1): Parsing failed.");
}
public void CanIndicateGenericErrors()
{
var failure = FailureMessage.Unknown();
failure.ToString().ShouldBe("Parsing failed.");
}
/// <summary>
/// Creates a new instance of <see cref="FailingParser{TValue}"/>.
/// </summary>
/// <param name="message">The failure message to appear on the result.</param>
public FailingParser(FailureMessage message = null)
{
_message = message ?? FailureMessage.Unknown();
}
public void CanIncludeUnknownErrors()
{
FailureMessages.Empty
.With(FailureMessage.Unknown())
.ToString().ShouldBe("Parsing failed.");
}
public void ReportsErrorState()
{
new Failure <object>(x, FailureMessage.Unknown()).Success.ShouldBeFalse();
}
public void HasRemainingUnparsedTokens()
{
new Failure <object>(x, FailureMessage.Unknown()).UnparsedTokens.ShouldBe(x);
new Failure <object>(endOfInput, FailureMessage.Unknown()).UnparsedTokens.ShouldBe(endOfInput);
}
public void ThrowsWhenAttemptingToGetParsedValue()
{
Func <object> inspectParsedValue = () => new Failure <object>(x, FailureMessage.Unknown()).ParsedValue;
inspectParsedValue.ShouldThrow <NotSupportedException>("(1, 1): Parsing failed.");
}
public void CanIndicateErrorsAtTheCurrentPosition()
{
new Failure <object>(endOfInput, FailureMessage.Unknown()).FailureMessages.ToString().ShouldBe("Parsing failed.");
new Failure <object>(endOfInput, FailureMessage.Expected("statement")).FailureMessages.ToString().ShouldBe("statement expected");
}
