public void CompileAndEvaluateComplexExpressionWithParenthesis() { Parser parser = new Parser("(6+3)/(1+2)"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BinaryOperatorExpression)); Assert.AreEqual(3, expression.Evaluate(new BindingEnvironment())); Assert.IsNull(parser.CompileExpression()); }
public void CompileAndEvaluateComplexListExpression() { Parser parser = new Parser("[1, 2, [a, b], 'spam']"); BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 1); environment.SetValue("b", 2); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); Assert.IsFalse(((ListExpression)expression).IsReadOnly); 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("spam", 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 void CompileAndEvaluateAddExpression() { Parser parser = new Parser("1+2"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BinaryOperatorExpression)); Assert.AreEqual(3, expression.Evaluate(new BindingEnvironment())); }
public object Apply(IContext context, IList<object> arguments, IDictionary<string, object> namedArguments) { int nargs = arguments == null ? 0 : arguments.Count; if (nargs == 0) throw new TypeError("eval expected at least 1 arguments, got 0"); // TODO implement bytes or code object if (!(arguments[0] is string)) throw new TypeError("eval() arg 1 must be a string, bytes or code object"); Parser parser = new Parser((string)arguments[0]); IExpression expression = parser.CompileExpression(); if (expression == null) return null; return expression.Evaluate(context); }
public void CompileAndEvaluateArrayAsListExpression() { Parser parser = new Parser("[1,2,'spam']"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); Assert.IsFalse(((ListExpression)expression).IsReadOnly); object result = expression.Evaluate(new BindingEnvironment()); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IList)); IList list = (IList)result; Assert.AreEqual(3, list.Count); Assert.AreEqual(1, list[0]); Assert.AreEqual(2, list[1]); Assert.AreEqual("spam", list[2]); }
public void CompileAttributeExpression() { Parser parser = new Parser("module.spam"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(AttributeExpression)); AttributeExpression attrexpr = (AttributeExpression)expression; Assert.IsNotNull(attrexpr.Expression); Assert.IsInstanceOfType(attrexpr.Expression, typeof(NameExpression)); Assert.AreEqual("spam", attrexpr.Name); }
public void CompileAndEvaluateNullDictionaryExpression() { Parser parser = new Parser("{ }"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(DictionaryExpression)); var dictexpr = (DictionaryExpression)expression; Assert.AreEqual(0, dictexpr.KeyExpressions.Count); Assert.AreEqual(0, dictexpr.ValueExpressions.Count); object result = expression.Evaluate(new BindingEnvironment()); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IDictionary)); IDictionary dictionary = (IDictionary)result; Assert.AreEqual(0, dictionary.Keys.Count); Assert.AreEqual(0, dictionary.Values.Count); }
public void CompileNoneAsNullConstantExpression() { Parser parser = new Parser("None"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); ConstantExpression cexpr = (ConstantExpression)expression; Assert.IsNull(cexpr.Value); }
public void CompileMethodCallExpression() { Parser parser = new Parser("foo.find('spam')"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(CallExpression)); CallExpression mcexpression = (CallExpression)expression; Assert.IsNotNull(mcexpression.TargetExpression); Assert.IsInstanceOfType(mcexpression.TargetExpression, typeof(AttributeExpression)); Assert.AreEqual("find", ((AttributeExpression)mcexpression.TargetExpression).Name); Assert.IsNotNull(mcexpression.ArgumentExpressions); Assert.AreEqual(1, mcexpression.ArgumentExpressions.Count); Assert.IsInstanceOfType(mcexpression.ArgumentExpressions[0], typeof(ConstantExpression)); }
public void CompileCallExpression() { Parser parser = new Parser("len('spam')"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(CallExpression)); }
public void CompileCompareExpression() { Parser parser = new Parser("a < b"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(CompareExpression)); Assert.IsNull(parser.CompileExpression()); }
public void CompileString() { Parser parser = new Parser("\"spam\""); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); Assert.AreEqual("spam", ((ConstantExpression)expression).Value); }
public void RaiseIfCompileListWithMissingComma() { Parser parser = new Parser("[1 2]"); parser.CompileExpression(); }
public void CompileSimpleExpressionInParenthesis() { Parser parser = new Parser("(1)"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); }
public void CompileSlicedExpressionWithNullEnd() { Parser parser = new Parser("'spam'[1:]"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(SlicedExpression)); SlicedExpression sexpr = (SlicedExpression)expression; Assert.AreEqual("spam", sexpr.TargetExpression.Evaluate(null)); Slice slice = (Slice)sexpr.SliceExpression.Evaluate(null); Assert.IsTrue(slice.Begin.HasValue); Assert.IsFalse(slice.End.HasValue); Assert.AreEqual(1, slice.Begin.Value); }
public void CompileOrExpression() { Parser parser = new Parser("2 or 3"); var expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BooleanExpression)); var booleanexpression = (BooleanExpression)expression; Assert.AreEqual(BooleanOperator.Or, booleanexpression.Operation); Assert.IsInstanceOfType(booleanexpression.Left, typeof(ConstantExpression)); Assert.IsInstanceOfType(booleanexpression.Right, typeof(ConstantExpression)); }
public void CompileNotExpression() { Parser parser = new Parser("not 3"); var expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(NotExpression)); var notexpression = (NotExpression)expression; Assert.IsInstanceOfType(notexpression.Expression, typeof(ConstantExpression)); }
public void CompileAndEvaluateDictionaryExpression() { Parser parser = new Parser("{ 'firstname': 'spam', 'lastname': 'bar' }"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(DictionaryExpression)); object result = expression.Evaluate(new BindingEnvironment()); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(IDictionary)); IDictionary dictionary = (IDictionary)result; Assert.AreEqual(2, dictionary.Keys.Count); Assert.AreEqual("spam", dictionary["firstname"]); Assert.AreEqual("bar", dictionary["lastname"]); }
public void CompileBoolean() { Parser parser = new Parser("true"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); Assert.AreEqual(true, ((ConstantExpression)expression).Value); Assert.IsNull(parser.CompileExpression()); }
public void CompileEmptyTupleExpression() { Parser parser = new Parser("()"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); var lexpr = (ListExpression)expression; Assert.IsTrue(lexpr.IsReadOnly); Assert.AreEqual(0, lexpr.Expressions.Count); }
public void CompileBooleanExpression() { Parser parser = new Parser("2 and 4 or not 3"); var expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(BooleanExpression)); var booleanexpression = (BooleanExpression)expression; Assert.AreEqual(BooleanOperator.Or, booleanexpression.Operation); Assert.IsInstanceOfType(booleanexpression.Left, typeof(BooleanExpression)); Assert.IsInstanceOfType(booleanexpression.Right, typeof(NotExpression)); var leftexpression = (BooleanExpression)booleanexpression.Left; Assert.AreEqual(BooleanOperator.And, leftexpression.Operation); }
public void CompileName() { Parser parser = new Parser("name"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(NameExpression)); Assert.AreEqual("name", ((NameExpression)expression).Name); }
public void CompileChainedNamedCalls() { Parser parser = new Parser("f.foo().bar()"); var expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(CallExpression)); var call = (CallExpression)expression; Assert.IsNotNull(call.TargetExpression); Assert.IsInstanceOfType(call.TargetExpression, typeof(AttributeExpression)); var attr = (AttributeExpression)call.TargetExpression; Assert.IsNotNull(attr.Expression); Assert.IsInstanceOfType(attr.Expression, typeof(CallExpression)); }
public void CompileInteger() { Parser parser = new Parser("123"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); Assert.AreEqual(123, ((ConstantExpression)expression).Value); Assert.IsNull(parser.CompileExpression()); }
public void RaiseIfDictionaryExpressionWithMissingPeriod() { Parser parser = new Parser("{ 'firstname' 'spam', 'lastname': 'bar' }"); parser.CompileExpression(); }
public void CompileNegateExpression() { Parser parser = new Parser("-3"); var expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(NegateExpression)); }
public void CompileFalseAsBooleanConstantExpression() { Parser parser = new Parser("False"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ConstantExpression)); ConstantExpression cexpr = (ConstantExpression)expression; Assert.AreEqual(false, cexpr.Value); }
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", "spam"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(ListExpression)); Assert.IsFalse(((ListExpression)expression).IsReadOnly); 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("spam", list[2]); }
public void CompileIndexedExpression() { Parser parser = new Parser("'spam'[1]"); IExpression expression = parser.CompileExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(IndexedExpression)); IndexedExpression iexpr = (IndexedExpression)expression; Assert.AreEqual("spam", iexpr.TargetExpression.Evaluate(null)); Assert.AreEqual(1, iexpr.IndexExpression.Evaluate(null)); }
private static object CompileAndEvaluateExpression(string text) { Machine machine = new Machine(); Parser parser = new Parser(text); IExpression expression = parser.CompileExpression(); Assert.IsNull(parser.CompileExpression()); return expression.Evaluate(machine.Environment); }