public void EvaluateUndefinedVariableAsNull()
{
BindingEnvironment environment = new BindingEnvironment();
IExpression expression = new VariableExpression("undefined");
Assert.IsNull(expression.Evaluate(environment));
}
public void UndefinedVariableIsNull()
{
BindingEnvironment environment = new BindingEnvironment();
VariableExpression var = new VariableExpression("foo");
Assert.IsNull(var.Evaluate(environment));
}
public void NotDefinedVariableSholdReturnNull()
{
BindingEnvironment environment = new BindingEnvironment();
VariableExpression variable = new VariableExpression("foo");
Assert.IsNull(variable.Evaluate(environment));
}
public void EvaluateUndefinedVariable()
{
Context context = new Context();
VariableExpression expr = new VariableExpression("Foo");
Assert.IsNull(expr.Evaluate(context));
}
public void EvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(variable, expression.Evaluate(context, true));
}
public static void TestWithoutVariableSupplied()
{
var expression = new VariableExpression("pie");
Assert.That(
() => expression.Evaluate(new Dictionary <string, object>()),
Throws.ArgumentException);
}
public static void TestWithNullVariableSupplied()
{
var expression = new VariableExpression("pie");
Assert.That(
() => expression.Evaluate(null),
Throws.ArgumentException);
}
public void EvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(variable, expression.Evaluate(context, true));
}
public void EvaluateDefinedVariable()
{
Context context = new Context();
context.SetValue("One", 1);
VariableExpression expr = new VariableExpression("One");
Assert.AreEqual(1, expr.Evaluate(context));
}
public void EvaluateVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
context.SetValue("X", 1);
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(1, expression.Evaluate(context));
}
public void Evaluate_ContextIsNull_ThrowsNullReferenceException()
{
var expr = new VariableExpression("Test");
Assert.Throws <NullReferenceException>(() =>
{
expr.Evaluate(null);
});
}
public void TestWithVariableSupplied()
{
var expression = new VariableExpression("pi");
Assert.AreEqual(Math.PI, expression.Evaluate(new Dictionary <string, object>
{
["pi"] = Math.PI
}));
}
public void Evaluate_VariableValueResolution_UsesContextToResolveVariable()
{
var expr = new VariableExpression("Count");
var contextMock = new Mock <IExpressionContext>();
expr.Evaluate(contextMock.Object);
contextMock.Verify(ctx => ctx.ResolveVariable("Count"), Times.Once);
}
public void EvaluateIntegerVariable()
{
BindingEnvironment environment = new BindingEnvironment();
IExpression expression = new VariableExpression("one");
environment.SetValue("one", 1);
Assert.AreEqual(1, expression.Evaluate(environment));
}
public static void TestWithVariableSupplied()
{
var expression = new VariableExpression("pi");
Assert.That(
expression.Evaluate(new Dictionary <string, object> {
["pi"] = Math.PI
}),
Is.EqualTo(Math.PI));
}
public void CreateAndEvaluateVariableExpression()
{
VariableExpression expression = new VariableExpression("foo");
Assert.AreEqual("foo", expression.Name);
Context context = new Context();
context.SetValue("foo", "bar");
Assert.AreEqual("bar", expression.Evaluate(context));
}
public void EvaluateVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
context.SetValue("X", 1);
VariableExpression expression = new VariableExpression(variable);
Assert.AreEqual(1, expression.Evaluate(context));
}
public void TestWithExpressionVariableSupplied()
{
var expression = new VariableExpression("pi");
var variable = Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)Math.PI);
Assert.AreEqual(Math.PI, expression.Evaluate(new Dictionary <string, object>
{
["pi"] = variable
}));
}
public void Evaluate_VariableValueIsNull_ReturnsNull()
{
var expr = new VariableExpression("Test");
var contextMock = new Mock <IExpressionContext>();
contextMock.Setup(ctx => ctx.ResolveVariable("Test")).Returns(null);
var value = expr.Evaluate <Null>(contextMock.Object).Value;
Assert.IsNull(value);
}
public void CreateAndEvaluateVariableExpression()
{
Context context = new Context();
context.SetValue("one", 1);
VariableExpression expr = new VariableExpression("one");
Assert.AreEqual("one", expr.Name);
Assert.AreEqual(1, expr.Evaluate(context));
Assert.AreSame(TypeInfo.Any, expr.TypeInfo);
}
public void EvaluateReturnsVariableNodeBinding()
{
Variable var = new Variable("scooby");
VariableExpression constraint = new VariableExpression(var);
Bindings bindings = new Bindings();
bindings.Bind(new Variable("scooby"), new Resource());
bindings.BindNode(new Variable("scooby"), new UriRef("http://example.com/scooby"));
Assert.AreEqual(new UriRef("http://example.com/scooby"), constraint.Evaluate(bindings));
}
public void ErrorEvaluateTest(string expression, string variable, int value)
{
var variableExpression = new VariableExpression();
VariableExpression.ClearVariables();
if (variable != null)
{
VariableExpression.AddVariable(variable, value);
}
Assert.Throws(typeof(ArithmeticException), () => variableExpression.Evaluate(expression));
}
public void SerializeDeserializeVariableExpressions()
{
BindingEnvironment environment = new BindingEnvironment();
environment.SetValue("foo", "bar");
environment.SetValue("one", 1);
VariableExpression varFoo = (VariableExpression)this.SerializeDeserialize(new VariableExpression("foo"));
VariableExpression varOne = (VariableExpression)this.SerializeDeserialize(new VariableExpression("one"));
Assert.AreEqual("bar", varFoo.Evaluate(environment));
Assert.AreEqual(1, varOne.Evaluate(environment));
}
public void EvaluateTest(string expression, int expectedResult, string variable, int value)
{
var variableExpression = new VariableExpression();
VariableExpression.ClearVariables();
if (variable != null)
{
VariableExpression.AddVariable(variable, value);
}
int result = variableExpression.Evaluate(expression);
Assert.That(result, Is.EqualTo(expectedResult));
}
public void RaiseIfEvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
try
{
expression.Evaluate(context, false);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual("variable 'X' is unbound", ex.Message);
}
}
public void RaiseIfEvaluateUndefinedVariableExpression()
{
Variable variable = new Variable("X");
Context context = new Context();
VariableExpression expression = new VariableExpression(variable);
try
{
expression.Evaluate(context, false);
Assert.Fail();
}
catch (Exception ex)
{
Assert.AreEqual("variable 'X' is unbound", ex.Message);
}
}
public void EvaluateDefinedMethod()
{
Context context = new Context();
IList <ICommand> commandlist = new List <ICommand>();
commandlist.Add(new SetVariableCommand("a", new ConstantExpression(1)));
commandlist.Add(new SetVariableCommand("b", new ConstantExpression(2)));
commandlist.Add(new ExpressionCommand(new VariableExpression("b")));
CompositeCommand commands = new CompositeCommand(commandlist);
DefinedMethod method = new DefinedMethod(null, commands);
context.SetValue("foo", method);
VariableExpression expr = new VariableExpression("foo");
Assert.AreEqual(2, expr.Evaluate(context));
}
public void DebugContextRaisingGettingValueEvent()
{
IContext context = new Context();
context.SetValue("foo", "bar");
DebugContext debug = new DebugContext(context);
string varname = null;
object varvalue = null;
debug.GettingValue += (name, value) => { varname = name; varvalue = value; };
IExpression expression = new VariableExpression("foo");
expression.Evaluate(debug);
Assert.AreEqual("foo", varname);
Assert.AreEqual("bar", varvalue);
}
public void EvaluateUndefinedVariable()
{
VariableExpression expr = new VariableExpression("Foo");
Assert.IsNull(expr.Evaluate(this.context));
}
public void EvaluateDefinedVariable()
{
VariableExpression expr = new VariableExpression("One");
Assert.AreEqual(1, expr.Evaluate(this.context));
}
