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()); }