public void Single_greater_comparison_with_constant_is_parsed_into_LessExpression_with_property_name_and_value() { var expression = _parser.Parse <Book>(x => x.PageCount > 500); var expectedExpression = new GreaterExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(500)); Assert.AreEqual(expectedExpression, expression); }
public bool GreaterBoolean(GreaterExpression node, List <object> parameters) { ExpressionNode lhs = node.Children[0]; ExpressionNode rhs = node.Children[1]; double lhsValue = _interpreter.DispatchReal(lhs, parameters); double rhsValue = _interpreter.DispatchReal(rhs, parameters); return(lhsValue > rhsValue); }
public void GreaterBoolean_Real_CorrectValuesReturned(double lhsValue, double rhsValue, bool expected) { var lhs = Utilities.GetRealLitExpression(); var rhs = Utilities.GetRealLitExpression(); var expression = new GreaterExpression(lhs, rhs, 0, 0); IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); parent.DispatchReal(lhs, Arg.Any <List <object> >()).Returns(lhsValue); parent.DispatchReal(rhs, Arg.Any <List <object> >()).Returns(rhsValue); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.GreaterBoolean(expression, new List <object>()); Assert.AreEqual(expected, res); }
public void GreaterBoolean_Real_CheckParametersPassedDown() { var lhs = Utilities.GetRealLitExpression(); var rhs = Utilities.GetRealLitExpression(); List <object> parameters = Utilities.GetParameterList(4); List <object> expectedParams = parameters; var expression = new GreaterExpression(lhs, rhs, 0, 0); IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); List <object> lhsParams = new List <object>(); List <object> rhsParams = new List <object>(); parent.DispatchReal(lhs, Arg.Do <List <object> >(x => lhsParams = x)); parent.DispatchReal(rhs, Arg.Do <List <object> >(x => rhsParams = x)); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); booleanHelper.GreaterBoolean(expression, parameters); Assert.AreEqual(expectedParams, lhsParams); Assert.AreEqual(expectedParams, rhsParams); }
/// <summary> /// Converts the parts of an expression into a FastDAO IExpression. /// Supported operators: gt, lt, ge, le, eq /// </summary> /// <param name="expressionParts">IDictionary with the following keys: /// "a" for the Attribute name /// "o" for the Operator /// "v" for the Value</param> /// <returns>A FastDAO IExpression</returns> private static IExpression DictionaryToExpression(IDictionary <string, object> expressionParts) { if (expressionParts == null) { throw new ArgumentNullException("expressionParts", "Cannot convert null to SQL expression"); } if (!expressionParts.ContainsKey(ATTRIBUTE_KEY)) { throw new ArgumentException("Missing the [" + ATTRIBUTE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts"); } if (!expressionParts.ContainsKey(OPERATOR_KEY)) { throw new ArgumentException("Missing the [" + OPERATOR_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts"); } if (!expressionParts.ContainsKey(VALUE_KEY)) { throw new ArgumentException("Missing the [" + VALUE_KEY + "] key from the expression parts. Cannot convert to SQL expression", "expressionParts"); } IExpression retVal; string attr = (string)expressionParts[ATTRIBUTE_KEY]; string oper = (string)expressionParts[OPERATOR_KEY]; object val = expressionParts[VALUE_KEY]; // Supported Operator Values: gt, lt, ge, le, eq, lk switch (oper) { case "eq": if (val is IList) { retVal = new PropertyInListExpression(attr, (IEnumerable)val); } else { retVal = new EqualExpression(attr, val); } break; case "gt": retVal = new GreaterExpression(attr, val); break; case "lt": retVal = new LesserExpression(attr, val); break; case "ge": retVal = new LesserExpression(attr, val, false); break; case "le": retVal = new GreaterExpression(attr, val, false); break; case "lk": retVal = new LikeExpression(attr, "%" + val + "%"); break; default: throw new ArgumentException("Cannot convert unsupported operator to SQL expression: " + oper); } return(retVal); }
public void Single_greater_comparison_with_constant_is_parsed_into_LessExpression_with_property_name_and_value() { var expression = _parser.Parse<Book>(x => x.PageCount > 500); var expectedExpression = new GreaterExpression(new PropertyExpression("PageCount", typeof(int)), new ValueExpression(500)); Assert.AreEqual(expectedExpression, expression); }
public void Visit(GreaterExpression expression) { VisitBinaryComparisonExpression(expression, ">"); }
public void TestGreaterExpression() { var e = new GreaterExpression(new ConstantExpression(15), new ConstantExpression(7)); e.Execute(_context, _stack); Assert.AreEqual(true, _stack.Pop()); Assert.IsFalse(_stack.Any()); var e2 = new GreaterExpression(new ConstantExpression(9), new ConstantExpression(9)); e2.Execute(_context, _stack); Assert.AreEqual(false, _stack.Pop()); Assert.IsFalse(_stack.Any()); }
public override void Visit(GreaterExpression node) { Visit((BinaryExpression)node); }
public override void Visit(GreaterExpression node) { unfinishedClone = new GreaterExpression(GetCloneOf(node.Left), GetCloneOf(node.Right)); base.Visit(node); }
public void Visit(GreaterExpression expression) { MatchCompareValues(expression.PropertyExpression.PropertyName, expression.ValueExpression.Value, 1); }
public override void Visit(GreaterExpression node) { UpdateType(node, TypeCalculator.GetType(node)); }
public override void Visit(GreaterExpression node) { AssignToImplicitReturn(node); }
public void SetUp(List <string> args) { if (verbose) { Console.WriteLine("import path:"); foreach (string directory in pathResolver.Directories) { Console.WriteLine(" " + directory); } } AppDomain domain = Thread.GetDomain(); rootModule = new Module(null, null); foreach (Assembly assembly in domain.GetAssemblies()) { AssemblyLoaded(assembly); } domain.AssemblyLoad += OnDomainAssemblyLoad; rootModule.SetName("null", null); rootModule.SetName("true", true); rootModule.SetName("false", false); rootModule.SetName("args", args); DefaultWhitespace.SetUp(rootModule, grammar); LineComment.SetUp(rootModule, grammar); BlockComment.SetUp(rootModule, grammar); Whitespace.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Name.SetUp(rootModule, grammar); Number.SetUp(rootModule, grammar); Base.String.SetUp(rootModule, grammar); Expression.SetUp(rootModule, grammar); ValueExpression.SetUp(rootModule, grammar); NameExpression.SetUp(rootModule, grammar); ParenExpression.SetUp(rootModule, grammar); MemberExpression.SetUp(rootModule, grammar); CallExpression.SetUp(rootModule, grammar); CallInParentScopeExpression.SetUp(rootModule, grammar); NewExpression.SetUp(rootModule, grammar); TypeExpression.SetUp(rootModule, grammar); IsExpression.SetUp(rootModule, grammar); AsExpression.SetUp(rootModule, grammar); UnaryExpression.SetUp(rootModule, grammar); NotExpression.SetUp(rootModule, grammar); MultiplicativeExpression.SetUp(rootModule, grammar); MultiplyExpression.SetUp(rootModule, grammar); DivideExpression.SetUp(rootModule, grammar); AdditiveExpression.SetUp(rootModule, grammar); AddExpression.SetUp(rootModule, grammar); SubtractExpression.SetUp(rootModule, grammar); ComparisonExpression.SetUp(rootModule, grammar); LessExpression.SetUp(rootModule, grammar); LessOrEqualExpression.SetUp(rootModule, grammar); EqualityExpression.SetUp(rootModule, grammar); InequalityExpression.SetUp(rootModule, grammar); GreaterExpression.SetUp(rootModule, grammar); GreaterOrEqualExpression.SetUp(rootModule, grammar); JunctionExpression.SetUp(rootModule, grammar); AndExpression.SetUp(rootModule, grammar); AssignmentExpression.SetUp(rootModule, grammar); AssignExpression.SetUp(rootModule, grammar); /* * NameExpression = ValueExpression * ParenExpression = ValueExpression * * CallExpression < ValueExpression * CallInParentScopeExpression = CallExpression * MemberExpression = CallExpression * * NewExpression < CallExpression * TypeExpression < NewExpression * UnaryExpression < TypeExpression * MultiplicativeExpression < UnaryExpression * AdditiveExpression < MultiplicativeExpression * ComparisonExpression < AdditiveExpression * JunctionExpression < ComparisonExpression * AssignmentExpression < JunctionExpression */ Precedence.SetPrecedence(NameExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(CallExpression.pattern.Precedence, ValueExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(CallInParentScopeExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(MemberExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(NewExpression.pattern.Precedence, CallExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(TypeExpression.pattern.Precedence, NewExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(UnaryExpression.pattern.Precedence, TypeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(MultiplicativeExpression.pattern.Precedence, UnaryExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AdditiveExpression.pattern.Precedence, MultiplicativeExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(ComparisonExpression.pattern.Precedence, AdditiveExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(JunctionExpression.pattern.Precedence, ComparisonExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AssignmentExpression.pattern.Precedence, JunctionExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ValueExpression.pattern, NameExpression.pattern, ParenExpression.pattern, MemberExpression.pattern, CallExpression.pattern, NewExpression.pattern, TypeExpression.pattern, UnaryExpression.pattern, MultiplicativeExpression.pattern, AdditiveExpression.pattern, ComparisonExpression.pattern, JunctionExpression.pattern, AssignmentExpression.pattern); PatternExpression.SetUp(rootModule, grammar); ReferencePatternExpression.SetUp(rootModule, grammar); AnyPatternExpression.SetUp(rootModule, grammar); TextPatternExpression.SetUp(rootModule, grammar); Option.SetUp(rootModule, grammar); BlockPatternExpression.SetUp(rootModule, grammar); ParenPatternExpression.SetUp(rootModule, grammar); TokenPatternExpression.SetUp(rootModule, grammar); RangePatternExpression.SetUp(rootModule, grammar); RepeatPatternExpression.SetUp(rootModule, grammar); AndPatternExpression.SetUp(rootModule, grammar); NotPatternExpression.SetUp(rootModule, grammar); LabelPatternExpression.SetUp(rootModule, grammar); SequencePatternExpression.SetUp(rootModule, grammar); AltPatternExpression.SetUp(rootModule, grammar); /* * EndPatternExpression = ReferencePatternExpression * AnyPatternExpression = ReferencePatternExpression * TextPatternExpression = ReferencePatternExpression * BlockPatternExpression = ReferencePatternExpression * ParenPatternExpression = ReferencePatternExpression * TokenPatternExpression = ReferencePatternExpression * * RangePatternExpression < ReferencePatternExpression * * AndPatternExpression < RangePatternExpression * NotPatternExpression = AndPatternExpression * RepeatPatternExpression = AndPatternExpression * * LabelPatternExpression < AndPatternExpression * SequencePatternExpression < LabelPatternExpression * AltPatternExpression < SequencePatternExpression */ Precedence.SetPrecedence(AnyPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TextPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(BlockPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(ParenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(TokenPatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RangePatternExpression.pattern.Precedence, ReferencePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AndPatternExpression.pattern.Precedence, RangePatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(NotPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(RepeatPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Equal); Precedence.SetPrecedence(LabelPatternExpression.pattern.Precedence, AndPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(SequencePatternExpression.pattern.Precedence, LabelPatternExpression.pattern.Precedence, Relation.Lower); Precedence.SetPrecedence(AltPatternExpression.pattern.Precedence, SequencePatternExpression.pattern.Precedence, Relation.Lower); Grammar.PatternChanged(ReferencePatternExpression.pattern, AnyPatternExpression.pattern, TextPatternExpression.pattern, BlockPatternExpression.pattern, ParenPatternExpression.pattern, TokenPatternExpression.pattern, RangePatternExpression.pattern, RepeatPatternExpression.pattern, AndPatternExpression.pattern, NotPatternExpression.pattern, LabelPatternExpression.pattern, SequencePatternExpression.pattern, AltPatternExpression.pattern); Statement.SetUp(rootModule, grammar); ExpressionStatement.SetUp(rootModule, grammar); CompoundStatement.SetUp(rootModule, grammar); PrintStatement.SetUp(rootModule, grammar); IfStatement.SetUp(rootModule, grammar); WhileStatement.SetUp(rootModule, grammar); ReturnStatement.SetUp(rootModule, grammar); ThrowStatement.SetUp(rootModule, grammar); TryStatement.SetUp(rootModule, grammar); ModuleStatement.SetUp(rootModule, grammar); FunctionStatement.SetUp(rootModule, grammar); Member.SetUp(rootModule, grammar); PatternMember.SetUp(rootModule, grammar); FieldMember.SetUp(rootModule, grammar); ConstructorMember.SetUp(rootModule, grammar); MethodMember.SetUp(rootModule, grammar); ClassStatement.SetUp(rootModule, grammar); SetPrecedenceStatement.SetUp(rootModule, grammar); UsingStatement.SetUp(rootModule, grammar); ImportStatement.SetUp(rootModule, grammar); TopLevelStatement.SetUp(rootModule, grammar); Program.SetUp(rootModule, grammar); Grammar.PatternChanged(Member.pattern, Statement.pattern); grammar.RootPattern = Program.pattern; hasBeenSetUp = true; }