public void CreateAssignDotCommand()
{
DotExpression leftvalue = (DotExpression)(new Parser("a.b")).ParseExpression();
IExpression value = new ConstantExpression(1);
AssignDotExpressions cmd = new AssignDotExpressions(leftvalue, value);
Assert.AreSame(leftvalue, cmd.LeftValue);
Assert.AreSame(value, cmd.Expression);
}
public void ParseAssignDotCommand()
{
Parser parser = new Parser("a.b = 2");
DotExpression dotexpr = (DotExpression)(new Parser("a.b")).ParseExpression();
var expected = new AssignDotExpressions(dotexpr, new ConstantExpression(2));
var result = parser.ParseCommand();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseCommand());
}
public IExpression ParseExpression()
{
IExpression expr = this.ParseNoAssignExpression();
if (expr == null)
{
return(null);
}
if (!(expr is NameExpression) && !(expr is ClassVarExpression) && !(expr is InstanceVarExpression) && !(expr is DotExpression) && !(expr is IndexedExpression))
{
return(expr);
}
var token = this.lexer.NextToken();
if (token == null)
{
return(expr);
}
if (token.Type != TokenType.Operator || token.Value != "=")
{
this.lexer.PushToken(token);
return(expr);
}
IExpression assignexpr = null;
if (expr is NameExpression)
{
assignexpr = new AssignExpression(((NameExpression)expr).Name, this.ParseExpression());
}
else if (expr is DotExpression)
{
assignexpr = new AssignDotExpressions((DotExpression)expr, this.ParseExpression());
}
else if (expr is InstanceVarExpression)
{
assignexpr = new AssignInstanceVarExpression(((InstanceVarExpression)expr).Name, this.ParseExpression());
}
else if (expr is ClassVarExpression)
{
assignexpr = new AssignClassVarExpression(((ClassVarExpression)expr).Name, this.ParseExpression());
}
else if (expr is IndexedExpression)
{
assignexpr = new AssignIndexedExpression(((IndexedExpression)expr).Expression, ((IndexedExpression)expr).IndexExpression, this.ParseExpression());
}
return(assignexpr);
}
public void ExecuteAssignDotCommandOnNativeProperty()
{
Person person = new Person();
Machine machine = new Machine();
machine.RootContext.SetLocalValue("p", person);
var leftvalue = (DotExpression)(new Parser("p.FirstName")).ParseExpression();
var value = new ConstantExpression("Adam");
AssignDotExpressions cmd = new AssignDotExpressions(leftvalue, value);
var result = cmd.Evaluate(machine.RootContext);
Assert.IsNotNull(result);
Assert.AreEqual("Adam", result);
Assert.AreEqual("Adam", person.FirstName);
}
public void Equals()
{
DotExpression expr1 = (DotExpression)(new Parser("a.b")).ParseExpression();
DotExpression expr2 = (DotExpression)(new Parser("a.c")).ParseExpression();
AssignDotExpressions cmd1 = new AssignDotExpressions(expr1, new ConstantExpression(1));
AssignDotExpressions cmd2 = new AssignDotExpressions(expr1, new ConstantExpression(2));
AssignDotExpressions cmd3 = new AssignDotExpressions(expr2, new ConstantExpression(1));
AssignDotExpressions cmd4 = new AssignDotExpressions(expr1, new ConstantExpression(1));
Assert.IsTrue(cmd1.Equals(cmd4));
Assert.IsTrue(cmd4.Equals(cmd1));
Assert.AreEqual(cmd1.GetHashCode(), cmd4.GetHashCode());
Assert.IsFalse(cmd1.Equals(null));
Assert.IsFalse(cmd1.Equals(cmd2));
Assert.IsFalse(cmd1.Equals(cmd3));
Assert.IsFalse(cmd1.Equals(123));
}
public void ExecuteAssignDotCommand()
{
Machine machine = new Machine();
var @class = new DynamicClass("Dog");
var method = new DefinedFunction((new Parser("@name = name")).ParseCommand(), new string[] { "name" }, machine.RootContext);
@class.SetInstanceMethod("name=", method);
var nero = @class.CreateInstance();
machine.RootContext.SetLocalValue("nero", nero);
var leftvalue = (DotExpression)(new Parser("nero.name")).ParseExpression();
var value = new ConstantExpression("Nero");
AssignDotExpressions cmd = new AssignDotExpressions(leftvalue, value);
var result = cmd.Evaluate(machine.RootContext);
Assert.IsNotNull(result);
Assert.AreEqual("Nero", result);
Assert.AreEqual("Nero", nero.GetValue("name"));
}
public void ExecuteAssignDotCommandWithUnknownMethod()
{
Machine machine = new Machine();
var @class = new DynamicClass("Dog");
var nero = @class.CreateInstance();
machine.RootContext.SetLocalValue("nero", nero);
var leftvalue = (DotExpression)(new Parser("nero.name")).ParseExpression();
var value = new ConstantExpression("Nero");
AssignDotExpressions cmd = new AssignDotExpressions(leftvalue, value);
try
{
cmd.Evaluate(machine.RootContext);
Assert.Fail();
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(NoMethodError));
}
}
