public void GetGlobalContext()
{
Machine machine = new Machine();
BindingEnvironment environment = new BindingEnvironment(machine.Environment);
Assert.AreEqual(machine.Environment, environment.GlobalContext);
}
public void Execute(Machine machine, BindingEnvironment environment)
{
while (!Predicates.IsFalse(this.condition.Evaluate(environment)))
{
this.command.Execute(machine, environment);
}
}
public void Execute(IContext context)
{
BindingEnvironment env = new BindingEnvironment(context);
IList<IType> bases = null;
if (this.baseExpressions != null && this.baseExpressions.Count > 0)
{
bases = new List<IType>();
foreach (var expr in this.baseExpressions)
bases.Add((IType)expr.Evaluate(context));
}
DefinedClass klass = new DefinedClass(this.name, bases, context);
this.body.Execute(klass);
foreach (var name in env.GetNames())
{
var value = env.GetValue(name);
var deffunc = value as DefinedFunction;
if (deffunc != null)
klass.SetMethod(deffunc.Name, deffunc);
}
klass.SetValue("__doc__", this.doc);
context.SetValue(this.name, klass);
}
public void GetGlobalContext()
{
Machine machine = new Machine();
BindingEnvironment environment = new BindingEnvironment(machine.Environment);
Assert.AreEqual(machine.Environment, environment.GlobalContext);
}
public void ExecuteCompositeCommand()
{
BindingEnvironment environment = new BindingEnvironment();
SetVariableCommand command1 = new SetVariableCommand("foo", new ConstantExpression("bar"));
SetVariableCommand command2 = new SetVariableCommand("one", new ConstantExpression(1));
SetVariableCommand command3 = new SetVariableCommand("bar", new VariableExpression("foo"));
List <ICommand> commands = new List <ICommand>();
commands.Add(command1);
commands.Add(command2);
commands.Add(command3);
CompositeCommand command = new CompositeCommand(commands);
environment.SetValue("foo", null);
environment.SetValue("one", null);
command.Execute(environment);
Assert.AreEqual("bar", environment.GetValue("foo"));
Assert.AreEqual(1, environment.GetValue("one"));
Assert.AreEqual("bar", environment.GetValue("bar"));
}
public void NotDefinedVariableSholdReturnNull()
{
BindingEnvironment environment = new BindingEnvironment();
VariableExpression variable = new VariableExpression("foo");
Assert.IsNull(variable.Evaluate(environment));
}
public void ExecuteSetArrayCommandWithDotExpression()
{
BindingEnvironment environment = new BindingEnvironment();
DotExpression dotexpr = new DotExpression(new VariableExpression("foo"), "Values");
SetArrayCommand command = new SetArrayCommand(dotexpr, new IExpression[] { new ConstantExpression(0) }, new ConstantExpression("bar"));
command.Execute(environment);
object obj = environment.GetValue("foo");
Assert.IsNotNull(obj);
Assert.IsInstanceOfType(obj, typeof(DynamicObject));
DynamicObject dynobj = (DynamicObject)obj;
object obj2 = dynobj.GetValue("Values");
Assert.IsNotNull(obj2);
Assert.IsInstanceOfType(obj2, typeof(IList));
IList list = (IList)obj2;
Assert.AreEqual(1, list.Count);
Assert.AreEqual("bar", list[0]);
}
public void ExecuteSetCommandWithComplexDotExpression()
{
BindingEnvironment environment = new BindingEnvironment();
DotExpression dot = new DotExpression(new VariableExpression("foo"), "Address");
DotExpression dotexpr = new DotExpression(dot, "Street");
SetCommand command = new SetCommand(dotexpr, new ConstantExpression("bar"));
command.Execute(environment);
object obj = environment.GetValue("foo");
Assert.IsNotNull(obj);
Assert.IsInstanceOfType(obj, typeof(DynamicObject));
DynamicObject dynobj = (DynamicObject)obj;
object obj2 = dynobj.GetValue("Address");
Assert.IsNotNull(obj2);
Assert.IsInstanceOfType(obj2, typeof(DynamicObject));
DynamicObject dynobj2 = (DynamicObject)obj2;
Assert.AreEqual("bar", dynobj2.GetValue("Street"));
}
public void ExecuteForCommand()
{
ICommand setX = new SetVariableCommand("x", new ConstantExpression(0));
ICommand setY = new SetVariableCommand("y", new ConstantExpression(0));
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand initialCommand = new CompositeCommand(commands);
IExpression condition = new CompareExpression(ComparisonOperator.Less, new VariableExpression("x"), new ConstantExpression(6));
IExpression addXtoY = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("y"), new VariableExpression("x"));
ICommand addToY = new SetVariableCommand("y", addXtoY);
ICommand endCommand = new SetVariableCommand("x", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("x"), new ConstantExpression(1)));
ForCommand forcmd = new ForCommand(initialCommand, condition, endCommand, addToY);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("y", null);
forcmd.Execute(environment);
Assert.AreEqual(15, environment.GetValue("y"));
}
public void GetCurrentContextNames()
{
BindingEnvironment context = new BindingEnvironment();
context.SetValue("zero", 0);
context.SetValue("one", 1);
context.SetValue("two", 2);
context.SetValue("three", 3);
var result = this.dir.Apply(context, null, null);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IList<string>));
var names = (IList<string>)result;
Assert.AreNotEqual(0, names.Count);
Assert.IsTrue(names.Contains("zero"));
Assert.IsTrue(names.Contains("one"));
Assert.IsTrue(names.Contains("two"));
Assert.IsTrue(names.Contains("three"));
var previous = string.Empty;
foreach (var name in names)
{
Assert.IsTrue(previous.CompareTo(name) < 0);
previous = name;
}
}
public override object Evaluate(BindingEnvironment environment)
{
object leftvalue;
object rightvalue;
leftvalue = this.Left.Evaluate(environment);
rightvalue = this.Right.Evaluate(environment);
switch (this.@operator)
{
case BinaryOperator.Add:
return(Numbers.Add(leftvalue, rightvalue));
case BinaryOperator.Subtract:
return(Numbers.Subtract(leftvalue, rightvalue));
case BinaryOperator.Multiply:
return(Numbers.Multiply(leftvalue, rightvalue));
case BinaryOperator.Divide:
return(Numbers.Divide(leftvalue, rightvalue));
case BinaryOperator.Power:
return(System.Convert.ToInt32(System.Math.Pow((int)leftvalue, (int)rightvalue)));
}
throw new System.InvalidOperationException();
}
public void CanCreate()
{
BindingEnvironment environment = new BindingEnvironment();
Assert.IsNotNull(environment);
Assert.AreSame(environment, environment.GetValue("Environment"));
}
public void UnifyNullTest()
{
var b = new BindingEnvironment();
Assert.IsFalse(b.Unify(null, "foo", null, out _));
Assert.IsTrue(b.Unify(null, null, null, out _));
}
public void UndefinedVariableIsNull()
{
BindingEnvironment environment = new BindingEnvironment();
VariableExpression var = new VariableExpression("foo");
Assert.IsNull(var.Evaluate(environment));
}
public void CanCreate()
{
BindingEnvironment environment = new BindingEnvironment();
Assert.IsNotNull(environment);
Assert.AreSame(environment, environment.GetValue("Environment"));
}
public void CompileAndEvaluateComplexListExpression()
{
Parser parser = new Parser("[1, 2, [a, b], 'foo']");
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("a", 1);
environment.SetValue("b", 2);
IExpression expression = parser.CompileExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(ListExpression));
object result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IList));
IList list = (IList)result;
Assert.AreEqual(4, list.Count);
Assert.AreEqual(1, list[0]);
Assert.AreEqual(2, list[1]);
Assert.IsNotNull(list[2]);
Assert.IsInstanceOfType(list[2], typeof(IList));
Assert.AreEqual("foo", list[3]);
IList list2 = (IList)list[2];
Assert.IsNotNull(list2);
Assert.AreEqual(2, list2.Count);
Assert.AreEqual(1, list2[0]);
Assert.AreEqual(2, list2[1]);
}
public object Evaluate(BindingEnvironment environment)
{
object leftValue = this.leftExpression.Evaluate(environment);
object rightValue = this.rigthExpression.Evaluate(environment);
return this.Apply(leftValue, rightValue);
}
public void ExecuteWhileCommand()
{
IExpression incrementX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new ConstantExpression(1), new VariableExpression("x"));
IExpression decrementY = new ArithmeticBinaryExpression(ArithmeticOperator.Subtract, new VariableExpression("y"), new ConstantExpression(1));
ICommand setX = new SetVariableCommand("x", incrementX);
ICommand setY = new SetVariableCommand("y", decrementY);
List <ICommand> commands = new List <ICommand>();
commands.Add(setX);
commands.Add(setY);
ICommand command = new CompositeCommand(commands);
IExpression yexpr = new VariableExpression("y");
WhileCommand whilecmd = new WhileCommand(yexpr, command);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("x", 0);
environment.SetValue("y", 5);
whilecmd.Execute(environment);
Assert.AreEqual(0, environment.GetValue("y"));
Assert.AreEqual(5, environment.GetValue("x"));
}
public void CompileAndEvaluateListWithExpressionsExpression()
{
Parser parser = new Parser("[a+1, b+2, c]");
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("a", 1);
environment.SetValue("b", 2);
environment.SetValue("c", "foo");
IExpression expression = parser.CompileExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(ListExpression));
object result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(IList));
IList list = (IList)result;
Assert.AreEqual(3, list.Count);
Assert.AreEqual(2, list[0]);
Assert.AreEqual(4, list[1]);
Assert.AreEqual("foo", list[2]);
}
public void SetAndGetValue()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
Assert.AreEqual("bar", environment.GetValue("foo"));
}
public void ExecSimpleText()
{
BindingEnvironment environment = new BindingEnvironment();
this.exec.Apply(environment, new object[] { "a = 1" }, null);
Assert.AreEqual(1, environment.GetValue("a"));
}
public void HasValue()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
Assert.IsTrue(environment.HasValue("foo"));
Assert.IsFalse(environment.HasValue("undefined"));
}
public void GetValueDefinedInParent()
{
BindingEnvironment parent = new BindingEnvironment();
parent.SetValue("foo", "bar");
BindingEnvironment environment = new BindingEnvironment(parent);
Assert.AreEqual("bar", environment.GetValue("foo"));
}
public void SetAndGetValue()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
Assert.AreEqual("bar", environment.GetValue("foo"));
}
public void HasValue()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
Assert.IsTrue(environment.HasValue("foo"));
Assert.IsFalse(environment.HasValue("undefined"));
}
public void GetValueFromParent()
{
BindingEnvironment parent = new BindingEnvironment();
parent.SetValue("one", 1);
BindingEnvironment environment = new BindingEnvironment(parent);
Assert.AreEqual(1, environment.GetValue("one"));
}
/// <summary>
/// Check argument and throw instantiation exception if necessary.
/// </summary>
public static void Check(object task, object arg, bool shouldBeInstantiated, BindingEnvironment e,
object[] args)
{
if (!(e.Resolve(arg) is LogicVariable) != shouldBeInstantiated)
{
throw new ArgumentInstantiationException(task, e, args);
}
}
public void ExecSimpleText()
{
BindingEnvironment environment = new BindingEnvironment();
this.exec.Apply(environment, new object[] { "a = 1" }, null);
Assert.AreEqual(1, environment.GetValue("a"));
}
public void SetVariable()
{
IExpression expression = new ConstantExpression(1);
BindingEnvironment environment = new BindingEnvironment();
ICommand command = new SetCommand("spam", expression);
command.Execute(environment);
Assert.AreEqual(1, environment.GetValue("spam"));
}
public void GetGlobalEnvironmentFromParent()
{
Machine machine = new Machine();
BindingEnvironment parent = new BindingEnvironment(machine.Environment);
parent.SetValue("one", 1);
BindingEnvironment environment = new BindingEnvironment(parent);
Assert.AreEqual(machine.Environment, environment.GlobalContext);
}
public void LoadCachedModule()
{
var context = new BindingEnvironment();
var module = ModuleUtilities.LoadModule("setvar", context);
var module2 = ModuleUtilities.LoadModule("setvar", context);
Assert.IsNotNull(module);
Assert.AreEqual(module, module2);
}
public void ExecCommandList()
{
BindingEnvironment environment = new BindingEnvironment();
this.exec.Apply(environment, new object[] { "a = 1; b = 2" }, null);
Assert.AreEqual(1, environment.GetValue("a"));
Assert.AreEqual(2, environment.GetValue("b"));
}
public void EvaluateNameWithNull()
{
NameExpression expression = new NameExpression("foo");
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", null);
Assert.IsNull(expression.Evaluate(environment));
}
public void CreateAndExecuteTryCommand()
{
BindingEnvironment environment = new BindingEnvironment();
ICommand body = new SetCommand("a", new ConstantExpression(1));
TryCommand command = new TryCommand(body);
command.Execute(environment);
Assert.AreEqual(1, environment.GetValue("a"));
}
public void EvaluateNameExpression()
{
NameExpression expression = new NameExpression("foo");
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
Assert.AreEqual("bar", expression.Evaluate(environment));
}
public void LoadSimpleModule()
{
var context = new BindingEnvironment();
var module = ModuleUtilities.LoadModule("setvar", context);
Assert.IsNotNull(module);
Assert.AreEqual(context, module.GlobalContext);
Assert.IsNotNull(module.GetValue("a"));
Assert.AreEqual("setvar module", module.GetValue("__doc__"));
}
public void GetValueFromGlobalContext()
{
BindingEnvironment global = new BindingEnvironment();
global.SetValue("one", 1);
Module module = new Module(global);
var result = module.GetValue("one");
Assert.IsNotNull(result);
Assert.AreEqual(1, result);
Assert.IsTrue(module.HasValue("one"));
}
public void CanCreate()
{
BindingEnvironment environment = new BindingEnvironment();
Assert.IsNotNull(environment);
Assert.IsNotNull(environment.GlobalContext);
Assert.AreEqual(environment, environment.GlobalContext);
Assert.IsNull(environment.Parent);
Assert.IsFalse(environment.HasReturnValue());
Assert.IsNull(environment.GetReturnValue());
}
public void SetAttributeInNativeObject()
{
BindingEnvironment environment = new BindingEnvironment();
Person adam = new Person();
environment.SetValue("adam", adam);
SetAttributeCommand command = new SetAttributeCommand(new NameExpression("adam"), "FirstName", new ConstantExpression("Adam"));
command.Execute(environment);
Assert.AreEqual("Adam", adam.FirstName);
}
public void ExecuteSimpleForOnEmptyList()
{
ICommand body = new SetCommand("b", new BinaryOperatorExpression(new NameExpression("a"), new NameExpression("b"), BinaryOperator.Add));
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("b", 0);
ForCommand command = new ForCommand("a", new ConstantExpression(new object[] { }), body);
command.Execute(environment);
Assert.AreEqual(0, environment.GetValue("b"));
}
public void CallNativeObjectMethodWithArguments()
{
Calculator calculator = new Calculator();
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("calculator", calculator);
CallExpression expression = new CallExpression(new AttributeExpression(new NameExpression("calculator"), "Add"), new IExpression[] { new ConstantExpression(1), new ConstantExpression(2) });
var result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.AreEqual(calculator.Add(1, 2), result);
}
public void CallNativeObjectMethodWithoutArguments()
{
Person person = new Person() { FirstName = "Adam", LastName = "Doe" };
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("adam", person);
CallExpression expression = new CallExpression(new AttributeExpression(new NameExpression("adam"), "GetName"), null);
var result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.AreEqual(person.GetName(), result);
}
public void DefineAndSetGlobalValue()
{
Machine machine = new Machine();
BindingEnvironment environment = new BindingEnvironment();
environment.DefineGlobal("global");
environment.SetValue("global", 100);
Assert.AreEqual(100, environment.GetValue("global"));
Assert.AreEqual(100, machine.Environment.GetValue("global"));
}
public void CallNativeTypeStaticMethod()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("File", typeof(System.IO.File));
CallExpression expression = new CallExpression(new AttributeExpression(new NameExpression("File"), "Exists"), new IExpression[] { new ConstantExpression("unknown.txt") });
var result = expression.Evaluate(environment);
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(bool));
Assert.AreEqual(false, result);
}
public void InvokeSimpleFunction()
{
ICommand body = new ReturnCommand(new VariableExpression("x"));
Function function = new Function(new string[] { "x" }, body);
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("x", 2);
object result = function.Invoke(environment, new object[] { 1 });
Assert.IsNotNull(result);
Assert.AreEqual(1, result);
}
public void GetLocalContext()
{
BindingEnvironment global = new BindingEnvironment();
BindingEnvironment local = new BindingEnvironment(global);
ContextFunction function = new ContextFunction("locals", false);
var result = function.Apply(local, null, null);
Assert.IsNotNull(result);
Assert.AreEqual(local, result);
Assert.IsFalse(function.IsGlobal);
Assert.AreEqual("locals", function.Name);
}
public void ExecuteClassCommandWithEmptyMethod()
{
BindingEnvironment environment = new BindingEnvironment();
ClassCommand command = new ClassCommand("Spam", new DefCommand("foo", null, new PassCommand()));
command.Execute(environment);
var result = (DefinedClass)environment.GetValue("Spam");
Assert.AreEqual("Spam", result.Name);
Assert.IsNotNull(result.GetMethod("foo"));
}
public void CreateSimpleClassWithEmptyDocString()
{
BindingEnvironment environment = new BindingEnvironment();
ClassCommand command = new ClassCommand("Spam", new PassCommand());
command.Execute(environment);
var result = environment.GetValue("Spam");
var dclass = (DefinedClass)result;
Assert.IsNull(dclass.GetValue("__doc__"));
Assert.IsTrue(dclass.HasValue("__doc__"));
}
