public static void SerializeLessThanOrEqualExpression()
{
var v = new NumberLiteral(2);
var a = new LessThanOrEqualExpression(v, v);
var b = SerializationUtil.Reserialize(a);
Assert.AreEqual(a, b);
}
public void TestIntFloatTrue()
{
var expression = new LessThanOrEqualExpression(
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)1.001),
ExpressiveOptions.None);
Assert.AreEqual(true, expression.Evaluate(null));
}
public void TestRightNull()
{
var expression = new LessThanOrEqualExpression(
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 static void TestEvaluate(object lhs, object rhs, object expectedValue)
{
var expression = new LessThanOrEqualExpression(
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 LessThanOrEqual(object l, object r)
{
var scope = new Scope();
scope.SetVar("l", l);
scope.SetVar("r", r);
var exp = new LessThanOrEqualExpression(
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(LessThanOrEqualExpression 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(LessThanOrEqualExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " <= " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
public IValue Visit(LessThanOrEqualExpression expression, TypeEnvironment environment)
{
return(expression.LeftExpression
.Accept(this, environment)
.LessThanOrEqualTo(expression.RightExpression.Accept(this, environment)));
}
public ValueType Visit(LessThanOrEqualExpression expression, ITypeEnvironment environment)
{
return(this.CheckBinaryComparisonExpression(expression, environment));
}
public virtual void VisitLessThanOrEqualExpression(LessThanOrEqualExpression lessThanOrEqualExpression)
{
DefaultVisit(lessThanOrEqualExpression);
}
private string GetExpression(LessThanOrEqualExpression expression, ref List <OleDbParameter> parameters)
{
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " <= " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ");
}
