public void ParseArrayExpression()
{
Parser parser = new Parser("[1,2,3]");
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ArrayExpression));
ArrayExpression expr = (ArrayExpression)result;
Assert.IsNotNull(expr.Expressions);
Assert.AreEqual(3, expr.Expressions.Count());
}
public void RaiseIfBinaryOperator()
{
Parser parser = new Parser("==");
parser.ParseExpression();
}
public void ParseVariable()
{
Parser parser = new Parser("foo");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(VariableExpression));
VariableExpression vexpr = (VariableExpression)expr;
Assert.AreEqual("foo", vexpr.Name);
Assert.IsNull(parser.ParseExpression());
}
public void ParseTrueAsConstant()
{
Parser parser = new Parser("true");
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ConstantExpression));
ConstantExpression expression = (ConstantExpression)result;
Assert.AreEqual(true, expression.Value);
}
public void ParseSimpleSum()
{
Parser parser = new Parser("1+2");
var result = parser.ParseExpression();
Assert.IsNull(parser.ParseExpression());
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ArithmeticBinaryExpression));
ArithmeticBinaryExpression expression = (ArithmeticBinaryExpression)result;
Assert.IsInstanceOfType(expression.LeftExpression, typeof(ConstantExpression));
Assert.IsInstanceOfType(expression.RightExpression, typeof(ConstantExpression));
}
public void ParseSimpleString()
{
Parser parser = new Parser("\"foo\"");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(ConstantExpression));
ConstantExpression cexpr = (ConstantExpression)expr;
Assert.AreEqual("foo", cexpr.Evaluate(null));
Assert.IsNull(parser.ParseExpression());
}
public void ParseClosingParenthesisAsNoExpression()
{
Parser parser = new Parser(")");
Assert.IsNull(parser.ParseExpression());
}
public void ParseDotExpression()
{
Parser parser = new Parser("a.length");
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(DotExpression));
DotExpression expression = (DotExpression)result;
Assert.AreEqual("length", expression.Name);
Assert.IsNull(expression.Arguments);
Assert.IsInstanceOfType(expression.Expression, typeof(VariableExpression));
}
public void ParseSimpleCall()
{
Parser parser = new Parser("prints(1)");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(CallExpression));
CallExpression cexpr = (CallExpression)expr;
Assert.IsInstanceOfType(cexpr.Expression, typeof(VariableExpression));
Assert.AreEqual(1, cexpr.Arguments.Count());
Assert.IsInstanceOfType(cexpr.Arguments.First(), typeof(ConstantExpression));
}
public void ParseNullAsConstant()
{
Parser parser = new Parser("null");
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ConstantExpression));
ConstantExpression expression = (ConstantExpression)result;
Assert.IsNull(expression.Value);
}
public void ParseLessOperator()
{
Parser parser = new Parser("a < 1");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(CompareExpression));
CompareExpression cexpr = (CompareExpression)expr;
Assert.AreEqual(ComparisonOperator.Less, cexpr.Operation);
Assert.IsInstanceOfType(cexpr.LeftExpression, typeof(VariableExpression));
Assert.IsInstanceOfType(cexpr.RightExpression, typeof(ConstantExpression));
Assert.IsNull(parser.ParseExpression());
}
public void ParseInteger()
{
Parser parser = new Parser("123");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(ConstantExpression));
ConstantExpression cexpr = (ConstantExpression)expr;
Assert.AreEqual(123, cexpr.Evaluate(null));
Assert.IsNull(parser.ParseExpression());
}
public void ParseDotExpressionWithArguments()
{
Parser parser = new Parser("a.slice(1)");
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(DotExpression));
DotExpression expression = (DotExpression)result;
Assert.AreEqual("slice", expression.Name);
Assert.IsNotNull(expression.Arguments);
Assert.AreEqual(1, expression.Arguments.Count());
Assert.IsInstanceOfType(expression.Expression, typeof(VariableExpression));
}
public void RaiseIfMissingClosingParenthesis()
{
Parser parser = new Parser("prints(1");
parser.ParseExpression();
}
public void ParseSimpleCallWithParenthesisAndTwoArguments()
{
Parser parser = new Parser("myfunc(a, b)");
IExpression expr = parser.ParseExpression();
Assert.IsNotNull(expr);
Assert.IsInstanceOfType(expr, typeof(CallExpression));
CallExpression cexpr = (CallExpression)expr;
Assert.IsInstanceOfType(cexpr.Expression, typeof(VariableExpression));
Assert.AreEqual(2, cexpr.Arguments.Count());
Assert.IsInstanceOfType(cexpr.Arguments.First(), typeof(VariableExpression));
Assert.IsInstanceOfType(cexpr.Arguments.Skip(1).First(), typeof(VariableExpression));
}
private static object EvaluateExpression(string text, Context context)
{
Parser parser = new Parser(text);
var result = parser.ParseExpression();
Assert.IsNull(parser.ParseExpression());
return result.Evaluate(context);
}
private IExpression ParseStringInterpolation(string text)
{
IList<IExpression> expressions = new List<IExpression>();
while (true)
{
int pos = text.IndexOf('$');
if (pos < 0)
{
if (!string.IsNullOrEmpty(text))
{
IExpression textexpr = new ConstantExpression(text);
expressions.Add(textexpr);
}
break;
}
if (pos == text.Length - 1)
throw new ParserException("Unexpected End of String");
string left = text.Substring(0, pos);
if (!string.IsNullOrEmpty(left))
expressions.Add(new ConstantExpression(left));
if (text[pos + 1] == '{')
{
int pos2 = text.IndexOf('}', pos + 1);
if (pos2 < 0)
throw new ParserException("Unexpected End of String");
string subtext = text.Substring(pos + 2, pos2 - pos - 2);
text = text.Substring(pos2 + 1);
Parser parser = new Parser(subtext);
IExpression newexpr = parser.ParseExpression();
if (parser.ParseExpression() != null)
throw new ParserException("Bad String Interpolation");
expressions.Add(newexpr);
}
else if (char.IsLetter(text[pos + 1]))
{
Parser parser = new Parser(text.Substring(pos + 1));
string name = parser.ParseName();
IExpression varexpr = new VariableExpression(name);
expressions.Add(varexpr);
text = text.Substring(pos + name.Length + 1);
}
else
throw new ParserException("Bad String Interpolation");
}
if (expressions.Count == 1)
return expressions[0];
IExpression expression = expressions[0];
foreach (var expr in expressions.Skip(1))
expression = new ArithmeticBinaryExpression(ArithmeticOperator.Add, expression, expr);
return expression;
}
