public void CreateUnaryExpression()
{
IExpression valueExpression = new ConstantExpression(1);
UnaryExpression expression = new ArithmeticUnaryExpression(ArithmeticOperator.Minus, valueExpression);
Assert.IsTrue(expression.Expression == valueExpression);
}
public void EvaluateConstantExpression()
{
ConstantExpression expression = new ConstantExpression("foo");
object result = this.host.Evaluate(expression);
Assert.IsNotNull(result);
Assert.AreEqual("foo", result);
}
public void CreateBinaryExpression()
{
IExpression leftExpression = new ConstantExpression(1);
IExpression rightExpression = new ConstantExpression(2);
BinaryExpression expression = new ArithmeticBinaryExpression(ArithmeticOperator.Add, leftExpression, rightExpression);
Assert.IsTrue(expression.LeftExpression == leftExpression);
Assert.IsTrue(expression.RightExpression == rightExpression);
}
public void CreateBinaryExpression()
{
IExpression leftExpression = new ConstantExpression(1);
IExpression rightExpression = new ConstantExpression(2);
BinaryExpression expression = (BinaryExpression)this.SerializeDeserialize(new ArithmeticBinaryExpression(ArithmeticOperator.Add, leftExpression, rightExpression));
Assert.AreEqual(1, expression.LeftExpression.Evaluate(null));
Assert.AreEqual(2, expression.RightExpression.Evaluate(null));
}
public void SerializeDeserializeConstantExpression()
{
ConstantExpression expression = new ConstantExpression("foo");
byte[] data = this.Serialize(expression);
object result = this.Deserialize(data);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(ConstantExpression));
ConstantExpression expression2 = (ConstantExpression)result;
Assert.AreEqual("foo", expression2.Evaluate(null));
}
private IExpression ParseSimpleTermExpression()
{
if (this.TryParse(TokenType.Name, "default"))
{
if (this.TryParse(TokenType.Name, "function") || this.TryParse(TokenType.Name, "sub"))
return this.ParseFunctionExpression(true);
throw new UnexpectedTokenException(this.lexer.NextToken());
}
if (this.TryParse(TokenType.Name, "function") || this.TryParse(TokenType.Name, "sub"))
return this.ParseFunctionExpression(false);
Token token = this.lexer.NextToken();
if (token == null)
return null;
switch (token.TokenType)
{
case TokenType.Separator:
if (token.Value == "(")
{
IExpression expr = this.ParseExpression();
this.Parse(TokenType.Separator, ")");
return expr;
}
break;
case TokenType.Boolean:
bool booleanValue = Convert.ToBoolean(token.Value);
return new ConstantExpression(booleanValue);
case TokenType.Integer:
int intValue = Int32.Parse(token.Value, System.Globalization.CultureInfo.InvariantCulture);
return new ConstantExpression(intValue);
case TokenType.Real:
double realValue = Double.Parse(token.Value, System.Globalization.CultureInfo.InvariantCulture);
return new ConstantExpression(realValue);
case TokenType.String:
IList<string> parts = StringUtilities.SplitText(token.Value);
if (parts.Count == 1)
return new ConstantExpression(token.Value);
IExpression strexpr = new ConstantExpression(parts[0]);
for (int k = 1; k < parts.Count; k++)
if ((k % 2) == 0)
strexpr = new ConcatenateExpression(strexpr, new ConstantExpression(parts[k]));
else
{
Parser parser = new Parser(parts[k]);
strexpr = new ConcatenateExpression(strexpr, parser.ParseExpression());
}
return strexpr;
case TokenType.Name:
if (this.TryParse(TokenType.Separator, "("))
{
List<IExpression> arguments = this.ParseArgumentList();
return new InvokeExpression(token.Value, arguments);
}
if (this.TryParse(TokenType.Operator, "..."))
{
this.lexer.NextToken();
return new VariableVariableExpression(token.Value);
}
return new VariableExpression(token.Value);
}
throw new UnexpectedTokenException(token);
}
public void ExecuteIfCommandWhenTrue()
{
IExpression condition = new ConstantExpression(true);
ICommand setCommand = new SetVariableCommand("x", new ConstantExpression(1));
IfCommand command = new IfCommand(condition, setCommand);
BindingEnvironment environment = new BindingEnvironment();
command.Execute(environment);
Assert.AreEqual(1, environment.GetValue("x"));
}
public void ExecuteIfCommandElseWhenFalse()
{
IExpression condition = new ConstantExpression(false);
ICommand setXCommand = new SetVariableCommand("x", new ConstantExpression(1));
ICommand setYCommand = new SetVariableCommand("y", new ConstantExpression(2));
IfCommand command = new IfCommand(condition, setXCommand, setYCommand);
BindingEnvironment environment = new BindingEnvironment();
command.Execute(environment);
Assert.IsNull(environment.GetValue("x"));
Assert.AreEqual(2, environment.GetValue("y"));
}
public void ExecuteForEachCommand()
{
IExpression addToX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("y"), new VariableExpression("x"));
ICommand setX = new SetVariableCommand("x", addToX);
IExpression values = new ConstantExpression(new int[] { 1, 2, 3 });
ForEachCommand foreachcmd = new ForEachCommand("y", values, setX);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("x", 0);
foreachcmd.Execute(environment);
Assert.AreEqual(6, environment.GetValue("x"));
}
