public void AddIntegerToDouble()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2.5));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(1 + 2.5, expr.Evaluate(null));
}
public void AddTwoIntegers()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2));
Assert.AreSame(TypeInfo.Int, expr.TypeInfo);
Assert.AreEqual(3, expr.Evaluate(null));
}
public void AddTwoIntegers()
{
AddExpression expr = new AddExpression(new ConstantExpression(1), new ConstantExpression(2));
Assert.AreEqual(3, expr.Evaluate(null));
Assert.IsFalse(expr.HasVariable());
}
public void AddDoubleToInteger()
{
AddExpression expr = new AddExpression(new ConstantExpression(2.5), new ConstantExpression(1));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(2.5 + 1, expr.Evaluate(null));
}
public void AddTwoDoubles()
{
AddExpression expr = new AddExpression(new ConstantExpression(2.5), new ConstantExpression(3.7));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
Assert.AreEqual(2.5 + 3.7, expr.Evaluate(null));
}
public void AddIntegerToString()
{
AddExpression expr = new AddExpression(new ConstantExpression(42), new ConstantExpression("1"));
Assert.AreSame(TypeInfo.String, expr.TypeInfo);
Assert.AreEqual("421", expr.Evaluate(null));
}
public void EvaluateTest(string expression, int expectedResult)
{
var addExpression = new AddExpression();
int result = addExpression.Evaluate(expression);
Assert.That(result, Is.EqualTo(expectedResult));
}
public void TestEvaluateWithDifferentSizedArrays()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1 }),
new Context(ExpressiveOptions.None));
Assert.IsNull(expression.Evaluate(null));
}
public void TestEvaluate()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)2),
ExpressiveOptions.None);
Assert.AreEqual(3, expression.Evaluate(null));
}
public void TestStringAddition()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)"1"),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)2),
new Context(ExpressiveOptions.None));
Assert.AreEqual("12", expression.Evaluate(null));
}
public void ShouldAddTwoRealNumbers()
{
IExpression expression = new AddExpression(1.2, 3.4);
object value = expression.Evaluate(null);
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(double));
Assert.AreEqual(4.6, (double)value);
}
public void AddIntegerAndVariable()
{
Context context = new Context();
context.SetValue("Two", 2);
AddExpression expr = new AddExpression(new ConstantExpression(1), new VariableExpression(new Variable("Two")));
Assert.AreEqual(3, expr.Evaluate(context));
Assert.IsTrue(expr.HasVariable());
}
public void AddVariableAndInteger()
{
Context context = new Context();
context.SetValue("One", 1);
AddExpression expr = new AddExpression(new VariableExpression(new Variable("One")), new ConstantExpression(2));
Assert.AreEqual(3, expr.Evaluate(context));
Assert.IsTrue(expr.HasVariable());
}
public void ShouldConcatenateStrings()
{
IExpression expression = new AddExpression("foo", "bar");
object value = expression.Evaluate(null);
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(string));
Assert.AreEqual("foobar", (string)value);
}
public void ShouldAddTwoDecimalNumbers()
{
IExpression expression = new AddExpression((decimal)1.2, (decimal)3.4);
object value = expression.Evaluate(null);
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(decimal));
Assert.AreEqual((decimal)4.6, (decimal)value);
}
public void TestPlusExpression()
{
IExpressionNode const1 = new ConstantExpression(5);
IExpressionNode const2 = new ConstantExpression(15);
IExpressionNode plusExpr = new AddExpression(const1, const2);
var result = plusExpr.Evaluate();
Assert.AreEqual(20, result);
}
public void ShouldAddTwoIntegerNumbers()
{
IExpression expression = new AddExpression(1, 2);
object value = expression.Evaluate(null);
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(int));
Assert.AreEqual(3, (int)value);
}
private object Add(object l, object r)
{
var scope = new Scope();
scope.SetVar("l", l);
scope.SetVar("r", r);
var exp = new AddExpression(
new VariableExpression("l"),
new VariableExpression("r")
);
return(exp.Evaluate(scope, new Bindings()).AsObject());
}
public void TestEvaluateWithSameSizedArrays()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
new Context(ExpressiveOptions.None));
var result = (object[])expression.Evaluate(null);
Assert.IsTrue(result.Length == 3);
Assert.AreEqual(result[0], 2);
Assert.AreEqual(result[1], 4);
Assert.AreEqual(result[2], 6);
}
public void TestEvaluateWithEmptyLeftArray()
{
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new int[0]),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
ExpressiveOptions.None);
var result = (object[])expression.Evaluate(null);
Assert.IsTrue(result.Length == 3);
// TODO: Is this result correct? Currently null + 1 == null so technically yes but should it be the same for an empty array or default to the data types default e.g. default(int)
Assert.AreEqual(result[0], null);
Assert.AreEqual(result[1], null);
Assert.AreEqual(result[2], null);
}
public void TestEvaluateWithEmptyLeftArray()
{
#pragma warning disable CA1825 // Avoid zero-length array allocations. - Array.Empty does not exist in net 4.5
var expression = new AddExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new int[0]),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)new[] { 1, 2, 3 }),
new Context(ExpressiveOptions.None));
#pragma warning restore CA1825 // Avoid zero-length array allocations.
var result = (object[])expression.Evaluate(null);
Assert.IsTrue(result.Length == 3);
// TODO: Is this result correct? Currently null + 1 is null so technically yes but should it be the same for an empty array or default to the data types default e.g. default(int)
Assert.AreEqual(result[0], null);
Assert.AreEqual(result[1], null);
Assert.AreEqual(result[2], null);
}
public void ErrorEvaluateTest(string expression)
{
var addExpression = new AddExpression();
Assert.Throws(typeof(ArithmeticException), () => addExpression.Evaluate(expression));
}
public void ShouldAdd()
{
var expr = new AddExpression(Constant(1), Constant(2));
Assert.Equal(3, expr.Evaluate());
}