public void CreatesNewCollectionWhenAddingItems()
{
ErrorMessageList list = ErrorMessageList.Empty.With(ErrorMessage.Expected("expectation"));
list.ToString().ShouldBe("expectation expected");
list.ShouldNotBeSameAs(ErrorMessageList.Empty);
}
public void CanIndicateSpecificExpectation()
{
var error = (ExpectedErrorMessage)ErrorMessage.Expected("statement");
error.Expectation.ShouldBe("statement");
error.ToString().ShouldBe("statement expected");
}
public void CanIncludeBacktrackErrors()
{
var deepBacktrack = ErrorMessage.Backtrack(new Position(3, 4),
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B")));
var shallowBacktrack = ErrorMessage.Backtrack(new Position(2, 3),
ErrorMessageList.Empty
.With(ErrorMessage.Expected("C"))
.With(ErrorMessage.Expected("D"))
.With(deepBacktrack));
var unrelatedBacktrack = ErrorMessage.Backtrack(new Position(1, 2),
ErrorMessageList.Empty
.With(ErrorMessage.Expected("E"))
.With(ErrorMessage.Expected("F")));
ErrorMessageList.Empty
.With(deepBacktrack)
.ToString().ShouldBe("[(3, 4): A or B expected]");
ErrorMessageList.Empty
.With(shallowBacktrack)
.ToString().ShouldBe("[(2, 3): C or D expected [(3, 4): A or B expected]]");
ErrorMessageList.Empty
.With(ErrorMessage.Expected("G"))
.With(ErrorMessage.Expected("H"))
.With(shallowBacktrack)
.With(unrelatedBacktrack)
.ToString().ShouldBe("G or H expected [(1, 2): E or F expected] [(2, 3): C or D expected [(3, 4): A or B expected]]");
}
public void CanIndicateMultipleErrorsAtTheCurrentPosition()
{
var errors = ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"));
new Error <object>(endOfInput, errors).ErrorMessages.ToString().ShouldBe("A or B expected");
}
public void CanIndicatePotentialErrors()
{
var potentialErrors = ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"));
new Parsed <object>("x", unparsed, potentialErrors).ErrorMessages.ShouldBe(potentialErrors);
}
public void OmitsUnknownErrorsWhenAdditionalErrorsExist()
{
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Unknown())
.With(ErrorMessage.Expected("C"))
.ToString().ShouldBe("A, B or C expected");
}
public void OmitsDuplicateExpectationsFromExpectationLists()
{
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Expected("C"))
.With(ErrorMessage.Unknown())
.With(ErrorMessage.Expected("C"))
.With(ErrorMessage.Expected("C"))
.With(ErrorMessage.Expected("A"))
.ToString().ShouldBe("A, B or C expected");
}
public void CanIndicateErrorsWhichCausedBacktracking()
{
var position = new Position(3, 4);
ErrorMessageList errors = ErrorMessageList.Empty
.With(ErrorMessage.Expected("a"))
.With(ErrorMessage.Expected("b"));
var error = (BacktrackErrorMessage)ErrorMessage.Backtrack(position, errors);
error.Position.ShouldBe(position);
error.Errors.ShouldBe(errors);
error.ToString().ShouldBe("(3, 4): a or b expected");
}
public void CanMergeTwoLists()
{
var first = ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Unknown())
.With(ErrorMessage.Expected("C"));
var second = ErrorMessageList.Empty
.With(ErrorMessage.Expected("D"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Unknown())
.With(ErrorMessage.Expected("E"));
first.Merge(second)
.ToString().ShouldBe("A, B, C, D or E expected");
}
public void CanIncludeMultipleExpectations()
{
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.ToString().ShouldBe("A or B expected");
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Expected("C"))
.ToString().ShouldBe("A, B or C expected");
ErrorMessageList.Empty
.With(ErrorMessage.Expected("A"))
.With(ErrorMessage.Expected("B"))
.With(ErrorMessage.Expected("C"))
.With(ErrorMessage.Expected("D"))
.ToString().ShouldBe("A, B, C or D expected");
}
public void CanIncludeUnknownErrors()
{
ErrorMessageList.Empty
.With(ErrorMessage.Unknown())
.ToString().ShouldBe("Parse error.");
}
public void CanIndicateGenericErrors()
{
var error = ErrorMessage.Unknown();
error.ToString().ShouldBe("Parse error.");
}
public void ReportsErrorState()
{
new Error <object>(x, ErrorMessage.Unknown()).Success.ShouldBeFalse();
}
public void HasRemainingUnparsedTokens()
{
new Error <object>(x, ErrorMessage.Unknown()).UnparsedTokens.ShouldBe(x);
new Error <object>(endOfInput, ErrorMessage.Unknown()).UnparsedTokens.ShouldBe(endOfInput);
}
public void ThrowsWhenAttemptingToGetParsedValue()
{
Func <object> inspectParsedValue = () => new Error <object>(x, ErrorMessage.Unknown()).Value;
inspectParsedValue.ShouldThrow <MemberAccessException>("(1, 1): Parse error.");
}
public void CreatesParsersFromLambdas()
{
var succeeds = new LambdaParser <string>(tokens => new Parsed <string>("AA", tokens.Advance().Advance()));
succeeds.PartiallyParses(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("B", "B").WithValue("AA");
var fails = new LambdaParser <string>(tokens => new Error <string>(tokens, ErrorMessage.Unknown()));
fails.FailsToParse(new CharLexer().Tokenize("AABB")).LeavingUnparsedTokens("A", "A", "B", "B").WithMessage("(1, 1): Parse error.");
}
public void CanIndicateErrorsAtTheCurrentPosition()
{
new Error <object>(endOfInput, ErrorMessage.Unknown()).ErrorMessages.ToString().ShouldBe("Parse error.");
new Error <object>(endOfInput, ErrorMessage.Expected("statement")).ErrorMessages.ToString().ShouldBe("statement expected");
}
