private Token[] Get(int offset, int count)
{
var r = new Token[count];
for (int i = 0; i < count; i++)
r[i] = Get(offset + i);
return r;
}
public void The_bad_token_type_should_be_in_the_error_message1()
{
var givenToken = new Token(TokenType.Literal, "DD", 0, 2);
var e = new UnexpectedTokenException(givenToken, TokenType.ArgumentValueDelimiter, null);
Assert.IsTrue(e.Message.Contains("DD"));
}
public void The_expected_token_type_should_be_in_the_error_message()
{
var givenToken = new Token(TokenType.Literal, "DD", 0, 2);
Assert.IsTrue(new UnexpectedTokenException(givenToken, TokenType.ArgumentValueDelimiter, null).Message.Contains("'='"));
Assert.IsTrue(new UnexpectedTokenException(givenToken, TokenType.Whitespace, null).Message.Contains("whitespace"));
Assert.IsTrue(new UnexpectedTokenException(givenToken, TokenType.Literal, LiteralTypeHint.Argument).Message.Contains("argument name"));
Assert.IsTrue(new UnexpectedTokenException(givenToken, TokenType.Literal, LiteralTypeHint.Value).Message.Contains("argument value"));
}
public UnexpectedTokenException(Token token, TokenType expectedTokenType, LiteralTypeHint? literalTypeHint) : base(token)
{
if (expectedTokenType == TokenType.Literal && literalTypeHint == null)
throw new ArgumentException($"If {nameof(expectedTokenType)} is {TokenType.Literal}, a {nameof(literalTypeHint)} has to be given.");
if (literalTypeHint != null && expectedTokenType != TokenType.Literal)
throw new ArgumentException($"{nameof(literalTypeHint)} has to be null if {nameof(expectedTokenType)} is not {nameof(TokenType.Literal)}");
ExpectedTokenType = expectedTokenType;
LiteralTypeHint = literalTypeHint;
}
private void CheckTokenizer(string text, Token[] result)
{
CollectionAssert.AreEqual(result, new Tokenizer().Tokenize(text), new TokenComparer());
}
public ICmdArgument[] Parse(Token[] tokens)
{
_tokens = tokens;
_index = 0;
var list = new List<ICmdArgument>();
while (true)
{
if (Get(0) == null)
return list.ToArray();
if (Get(0)?.Type == TokenType.Whitespace)
{
_index++;
continue;
}
var rules = new[]
{
IfTokenOrder
.Is(TokenType.ArgumentValueDelimiter)
.Throw<UnexpectedTokenException>(0, TokenType.Literal, LiteralTypeHint.Argument),
IfTokenOrder
.Is(TokenType.Literal, TokenType.ArgumentValueDelimiter, TokenType.ArgumentValueDelimiter)
.Throw<UnexpectedTokenException>(2, TokenType.Literal, LiteralTypeHint.Value),
IfTokenOrder
.Is(TokenType.Literal, TokenType.Whitespace, TokenType.ArgumentValueDelimiter)
.Throw<UnexpectedTokenException>(1, TokenType.ArgumentValueDelimiter),
IfTokenOrder
.Is(TokenType.Literal, TokenType.ArgumentValueDelimiter)
.AndEndsWithOneOfThese(TokenType.Whitespace, null)
.Throw<UnexpectedTokenException>(2, TokenType.Literal, LiteralTypeHint.Value),
IfTokenOrder
.Is(TokenType.Literal, TokenType.ArgumentValueDelimiter, TokenType.Literal)
.AndEndsWithOneOfThese(TokenType.Literal, TokenType.ArgumentValueDelimiter)
.Throw<UnexpectedTokenException>(3, TokenType.Whitespace),
IfTokenOrder
.Is(TokenType.Literal, TokenType.Literal)
.Throw<UnexpectedTokenException>(1, TokenType.Whitespace),
IfTokenOrder
.Is(TokenType.Literal)
.AndEndsWithOneOfThese(null, TokenType.Literal, TokenType.Whitespace)
.NameIsOnIndex(0),
IfTokenOrder
.Is(TokenType.Literal, TokenType.ArgumentValueDelimiter, TokenType.Literal)
.AndEndsWithOneOfThese(null, TokenType.Whitespace)
.NameIsOnIndex(0)
.ArgumentIsOnIndex(2)
};
var matchingRule = FindFirstMatchingRule(rules);
if (matchingRule == null)
throw new SyntaxErrorException(Get(0));
if (matchingRule.ExceptionToThrow != null)
throw CreateExceptionFromRule(matchingRule);
list.Add(CreateArgumentFromRule(matchingRule));
_index += matchingRule.TokensCount;
}
}
public SyntaxErrorException(Token badToken)
{
BadToken = badToken;
}
public void The_bad_token_type_should_be_in_the_error_message2()
{
var givenToken = new Token(TokenType.Whitespace, " ", 0, 2);
Assert.IsTrue(new UnexpectedTokenException(givenToken, TokenType.ArgumentValueDelimiter, null).Message.Contains("whitespace"));
}
