public static void SerializeGreaterThanOrEqualExpression() { var v = new NumberLiteral(2); var a = new GreaterThanOrEqualExpression(v, v); var b = SerializationUtil.Reserialize(a); Assert.AreEqual(a, b); }
public void TestRightNull() { var expression = new GreaterThanOrEqualExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)false), Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)null), ExpressiveOptions.None); Assert.AreEqual(null, expression.Evaluate(null)); }
public void TestIntFloatTrue() { var expression = new GreaterThanOrEqualExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1.001), Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1), ExpressiveOptions.None); Assert.AreEqual(true, expression.Evaluate(null)); }
public static void TestEvaluate(object lhs, object rhs, object expectedValue) { var expression = new GreaterThanOrEqualExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == lhs), Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == rhs), new Context(ExpressiveOptions.None)); Assert.That(expression.Evaluate(null), Is.EqualTo(expectedValue)); }
private object GreaterThanOrEqual(object l, object r) { var scope = new Scope(); scope.SetVar("l", l); scope.SetVar("r", r); var exp = new GreaterThanOrEqualExpression( new VariableExpression("l"), new VariableExpression("r") ); return(exp.Evaluate(scope, new Bindings()).AsObject()); }
public override AstNode VisitCompare([NotNull] QlParser.CompareContext context) { var op = context.op.Text; BinaryExpression binExp = null; var lhs = this.Visit(context.lhs) as Expression; var rhs = this.Visit(context.rhs) as Expression; switch (op) { case "<": binExp = new LessThanExpression(lhs, rhs); break; case "<=": binExp = new LessThanOrEqualExpression(lhs, rhs); break; case ">": binExp = new GreaterThanExpression(lhs, rhs); break; case ">=": binExp = new GreaterThanOrEqualExpression(lhs, rhs); break; case "==": binExp = new EqualExpression(lhs, rhs); break; case "!=": binExp = new NotEqualExpression(lhs, rhs); break; default: throw new ArgumentOutOfRangeException(nameof(op), "Unsupported operator."); } return(binExp); }
public virtual TResult Visit(GreaterThanOrEqualExpression expression, TEnvironment environment) { return(this.Visit((BinaryExpression)expression, environment)); }
private bool ParseRelationalOperatorIfExists(Lexer lexer, Token token, Attributes attributes) { var successfullyParsed = true; successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, token, attributes); if (lexer.GetCurrentToken().Is(TokenType.EqualOperator) || lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator) || lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator) || lexer.GetCurrentToken().Is(TokenType.LessThanOperator) || lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator) || lexer.GetCurrentToken().Is(TokenType.DistinctOperator)) { BinaryExpression tree; if (lexer.GetCurrentToken().Is(TokenType.EqualOperator)) { tree = new EqualExpression(); } else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOperator)) { tree = new GreaterThanExpression(); } else if (lexer.GetCurrentToken().Is(TokenType.GreaterThanOrEqualOperator)) { tree = new GreaterThanOrEqualExpression(); } else if (lexer.GetCurrentToken().Is(TokenType.LessThanOperator)) { tree = new LessThanExpression(); } else if (lexer.GetCurrentToken().Is(TokenType.LessThanOrEqualOperator)) { tree = new LessThanOrEqualExpression(); } else { tree = new DistinctExpression(); } tree.LeftOperand = attributes["EXP"] as Expression; successfullyParsed &= ParseAdditionOrSubstractionIfExists(lexer, lexer.GetNextToken(), attributes); tree.RightOperand = attributes["EXP"] as Expression; // SEM: Sólo pueden compararse expresiones del mismo tipo if (tree.LeftOperand.Type != tree.RightOperand.Type) { LogTypeMismatch(lexer.GetCurrentToken(), tree.LeftOperand.Type, tree.RightOperand.Type); successfullyParsed = false; } // SEM: Las comparaciones de tipo >, >=, <, <= sólo pueden realizarse entre enteros else if (!lexer.GetCurrentToken().Is(TokenType.EqualOperator) && !lexer.GetCurrentToken().Is(TokenType.DistinctOperator) && tree.LeftOperand.Type != DataType.Integer) { LogTypeExpressionInvalid(lexer.GetCurrentToken(), DataType.Integer, tree.LeftOperand.Type); successfullyParsed = false; } attributes["EXP"] = tree; } return(successfullyParsed); }
private string GetExpression(GreaterThanOrEqualExpression expression, ref List<OleDbParameter> parameters) { return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " >= " + GetExpressionDispatch(expression.Children[1], ref parameters) + " ) "; }
public IValue Visit(GreaterThanOrEqualExpression expression, TypeEnvironment environment) { return(expression.LeftExpression .Accept(this, environment) .GreaterThanOrEqualTo(expression.RightExpression.Accept(this, environment))); }
public ValueType Visit(GreaterThanOrEqualExpression expression, ITypeEnvironment environment) { return(this.CheckBinaryComparisonExpression(expression, environment)); }
public virtual void VisitGreaterThanOrEqualExpression(GreaterThanOrEqualExpression greaterThanOrEqualExpression) { DefaultVisit(greaterThanOrEqualExpression); }
private string GetExpression(GreaterThanOrEqualExpression expression, ref List <OleDbParameter> parameters) { return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " >= " + GetExpressionDispatch(expression.Children[1], ref parameters) + " ) "); }