public bool EqualBoolean(EqualExpression node, List <object> parameters) { ExpressionNode lhs = node.Children[0]; ExpressionNode rhs = node.Children[1]; return(IsEqual(lhs, rhs, node.Type, parameters)); }
public void EqualIntegerReal() { EqualExpression expr = new EqualExpression(new ConstantExpression(1), new ConstantExpression(1.0)); Assert.AreEqual(true, expr.Evaluate(null)); Assert.AreSame(TypeInfo.Boolean, expr.TypeInfo); }
public void EqualBoolean_Element_CheckParametersPassedDown() { var lhs = Utilities.GetBoolLitExpression(); var rhs = Utilities.GetBoolLitExpression(); List <object> parameters = Utilities.GetParameterList(4); List <object> expectedParams = parameters; var expression = new EqualExpression(lhs, rhs, 0, 0); expression.Type = TypeEnum.Element; IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); List <object> lhsParams = new List <object>(); List <object> rhsParams = new List <object>(); Element testElement = new Element(17); parent.DispatchElement(lhs, Arg.Do <List <object> >(x => lhsParams = x)).Returns(testElement); parent.DispatchElement(rhs, Arg.Do <List <object> >(x => rhsParams = x)).Returns(testElement); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); booleanHelper.EqualBoolean(expression, parameters); Assert.AreEqual(expectedParams, lhsParams); Assert.AreEqual(expectedParams, rhsParams); }
private IExpression ParseBinaryExpression(int level) { if (level >= binaryoperators.Length) { return(this.ParseTerm()); } IExpression expr = this.ParseBinaryExpression(level + 1); if (expr == null) { return(null); } Token token; for (token = this.lexer.NextToken(); token != null && this.IsBinaryOperator(level, token); token = this.lexer.NextToken()) { if (token.Value == "=:=") { expr = new StrictEqualExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "==") { expr = new EqualExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "+") { expr = new AddExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "-") { expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "*") { expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "/") { expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "div") { expr = new DivExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "rem") { expr = new RemExpression(expr, this.ParseBinaryExpression(level + 1)); } } if (token != null) { this.lexer.PushToken(token); } return(expr); }
public void EqualExpression() { var e = new EqualExpression(new Literal("13"), new Literal("37")); Assert.IsFalse(e.IsTrivial); Assert.AreEqual("(13==37)", e.ToString()); Assert.AreEqual("Equal", e.Name); }
public Justification(EqualExpression expression, RuleApplication ra) { m_expr = expression; var list = new List <RuleApplication>(1); list.Add(ra); m_ras = new ReadOnlyCollection <RuleApplication>(list); }
public Justification(EqualExpression expression, IEnumerable <RuleApplication> ras) { m_expr = expression; var list = new List <RuleApplication>(ras); list.TrimExcess(); m_ras = new ReadOnlyCollection <RuleApplication>(list); }
/// <summary> /// 產生EqualExpression /// </summary> /// <returns>EqualExpression</returns> public EqualExpression CreateEqualExpression() { decimal.TryParse(NumberStr, out decimal number); var equalExpression = new EqualExpression(number: number, leftBracket: LeftBracket, rightBracket: RightBracket, unaryList: UnaryList); InitThis(); return(equalExpression); }
ISemantic E(EqualExpression x, ISemantic lValue = null, ISemantic rValue = null) { var l = TryGetValue(lValue ?? E(x.LeftOperand)); var r = TryGetValue(rValue ?? E(x.RightOperand)); var isEq = SymbolValueComparer.IsEqual(l, r); return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x)); }
public void TestRightNull() { var expression = new EqualExpression( 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(false, expression.Evaluate(null)); }
public void TestIntFloatEqual() { var expression = new EqualExpression( 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.00), ExpressiveOptions.None); Assert.AreEqual(true, expression.Evaluate(null)); }
public static void TestEvaluate(object lhs, object rhs, object expectedValue) { var expression = new EqualExpression( 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)); }
public ISymbolValue Visit(EqualExpression x) { var lValue = this.lValue ?? (x.LeftOperand != null ? x.LeftOperand.Accept(this) : null); var rValue = this.rValue ?? (x.RightOperand != null ? x.RightOperand.Accept(this) : null); this.lValue = null; this.rValue = null; var l = TryGetValue(lValue); var r = TryGetValue(rValue); var isEq = SymbolValueComparer.IsEqual(l, r); return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x)); }
public void EqualBoolean_Bool_CorrectValuesReturned(bool lhsValue, bool rhsValue, bool expected) { var lhs = Utilities.GetRealLitExpression(); var rhs = Utilities.GetRealLitExpression(); EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0); expression.Type = TypeEnum.Boolean; IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); parent.DispatchBoolean(lhs, Arg.Any <List <object> >()).Returns(lhsValue); parent.DispatchBoolean(rhs, Arg.Any <List <object> >()).Returns(rhsValue); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.EqualBoolean(expression, new List <object>()); Assert.AreEqual(expected, res); }
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 void EqualBoolean_Set_CorrectValuesReturned(int leftDataRow, int rightDataRow, bool expected) { Set lhsValue = GetSet(leftDataRow); Set rhsValue = GetSet(rightDataRow); var lhs = Utilities.GetRealLitExpression(); var rhs = Utilities.GetRealLitExpression(); EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0); expression.Type = TypeEnum.Set; IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); parent.DispatchSet(lhs, Arg.Any <List <object> >()).Returns(lhsValue); parent.DispatchSet(rhs, Arg.Any <List <object> >()).Returns(rhsValue); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.EqualBoolean(expression, new List <object>()); Assert.AreEqual(expected, res); }
ISemantic E(EqualExpression x, ISemantic lValue = null, ISemantic rValue = null) { var l = TryGetValue(lValue ?? E(x.LeftOperand)); var r = TryGetValue(rValue ?? E(x.RightOperand)); bool isEq = false; // If they are integral values or pointers, equality is defined as the bit pattern of the type matches exactly if (l is PrimitiveValue && r is PrimitiveValue) { var pv_l = (PrimitiveValue)l; var pv_r = (PrimitiveValue)r; isEq = pv_l.Value == pv_r.Value && pv_l.ImaginaryPart == pv_r.ImaginaryPart; } /* * Furthermore TODO: object comparison, pointer content comparison */ return(new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x)); }
public void EqualBoolean_Element_CorrectValuesReturned(int[] a, int[] b, bool expected) { Element lhsValue = new Element(a.ToList()); Element rhsValue = new Element(b.ToList()); var lhs = Utilities.GetRealLitExpression(); var rhs = Utilities.GetRealLitExpression(); EqualExpression expression = new EqualExpression(lhs, rhs, 0, 0); expression.Type = TypeEnum.Element; IInterpreterBoolean parent = Substitute.For <IInterpreterBoolean>(); parent.DispatchElement(lhs, Arg.Any <List <object> >()).Returns(lhsValue); parent.DispatchElement(rhs, Arg.Any <List <object> >()).Returns(rhsValue); BooleanHelper booleanHelper = Utilities.GetBooleanHelper(parent); bool res = booleanHelper.EqualBoolean(expression, new List <object>()); Assert.AreEqual(expected, res); }
/// <summary> /// 取得運算結果。body可能會有數字(int)、右括號(bool)、單元運算列(List(char)) /// </summary> /// <param name="userIdForAns">用戶ID</param> /// <returns>運算結果</returns> public IHttpActionResult PostAnswer(int userIdForAns) { //讀取body EqualExpression equalexpression = Request.Content.ReadAsAsync <EqualExpression>().Result; ExpressionController expController = Users.GetExpressionController(userIdForAns); List <UnaryOperator> unaryList = (equalexpression.UnaryList == null) ? new List <UnaryOperator>() : equalexpression.UnaryList.Select(x => Operators.GetUnary(x)).ToList(); decimal?number = equalexpression.Number; decimal ans = 0; try { switch (equalexpression.Type()) { case EqualType.NUM_EQUAL: expController.Add(number.Value, unaryList); ans = expController.GetResult(); break; case EqualType.NUM_RB_EQUAL: expController.Add(number.Value, unaryList); expController.RightBracket(); ans = expController.GetResult(); break; default: throw new Exception("EqualType錯誤"); } } catch (Exception) { expController.Clear(); return(Ok("fail")); } return(Ok(ans)); }
public void NotEqualReals() { EqualExpression expr = new EqualExpression(new ConstantExpression(1.3), new ConstantExpression(2.4)); Assert.AreEqual(false, expr.Evaluate(null)); }
public void NotEqualIntegers() { EqualExpression expr = new EqualExpression(new ConstantExpression(1), new ConstantExpression(2)); Assert.AreEqual(false, expr.Evaluate(null)); }
public ISymbolValue Visit(EqualExpression x) { var lValue = this.lValue ?? (x.LeftOperand != null ? x.LeftOperand.Accept(this) : null); var rValue = this.rValue ?? (x.RightOperand != null ? x.RightOperand.Accept(this) : null); this.lValue = null; this.rValue = null; var l = TryGetValue(lValue); var r = TryGetValue(rValue); var isEq = SymbolValueComparer.IsEqual(l, r); return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq); }
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); }
public void Visit(EqualExpression x) { }
IExpression ParseAsmEqualExpression(IBlockNode Scope, IStatement Parent) { var left = ParseAsmRelExpression(Scope, Parent); while (laKind == Equal || laKind == NotEqual) { Step(); var e = new EqualExpression(t.Kind == NotEqual); e.LeftOperand = left; e.RightOperand = ParseAsmRelExpression(Scope, Parent); left = e; } return left; }
IExpression CmpExpression(IBlockNode Scope = null) { // TODO: Make this into a switch. var left = ShiftExpression(Scope); OperatorBasedExpression ae = null; // Equality Expressions if (laKind == Equal || laKind == NotEqual) ae = new EqualExpression(laKind == NotEqual); // Relational Expressions else if (IsRelationalOperator(laKind)) ae = new RelExpression(laKind); // Identity Expressions else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is)) ae = new IdentityExpression(laKind == Not); // In Expressions else if (laKind == In || (laKind == Not && Peek(1).Kind == In)) ae = new InExpression(laKind == Not); else return left; // Skip possible !-Token if (laKind == Not) Step(); // Skip operator Step(); ae.LeftOperand = left; ae.RightOperand = ShiftExpression(Scope); return ae; }
IExpression CmpExpression(IBlockNode Scope = null) { // TODO: Make this into a switch. var left = ShiftExpression(Scope); OperatorBasedExpression ae; switch (laKind) { case DTokens.Equal: case DTokens.NotEqual: ae = new EqualExpression (laKind == NotEqual); break; case DTokens.LessThan: case DTokens.LessEqual: case DTokens.GreaterThan: case DTokens.GreaterEqual: case DTokens.Unordered: case DTokens.LessOrGreater: case DTokens.LessEqualOrGreater: case DTokens.UnorderedOrGreater: case DTokens.UnorderedGreaterOrEqual: case DTokens.UnorderedOrLess: case DTokens.UnorderedLessOrEqual: case DTokens.UnorderedOrEqual: ae = new RelExpression (laKind); break; case DTokens.Is: ae = new IdentityExpression (false); break; case DTokens.In: ae = new InExpression (false); break; case Not: switch (Peek (1).Kind) { case DTokens.Is: ae = new IdentityExpression (false); Step (); break; case DTokens.In: ae = new InExpression (true); Step (); break; default: return left; } break; default: return left; } // Skip operator Step(); ae.LeftOperand = left; ae.RightOperand = ShiftExpression(Scope); return ae; }
ISemantic E(EqualExpression x, ISemantic lValue =null, ISemantic rValue = null) { var l = TryGetValue(lValue ?? E(x.LeftOperand)); var r = TryGetValue(rValue ?? E(x.RightOperand)); bool isEq = false; // If they are integral values or pointers, equality is defined as the bit pattern of the type matches exactly if (l is PrimitiveValue && r is PrimitiveValue) { var pv_l = (PrimitiveValue)l; var pv_r = (PrimitiveValue)r; isEq = pv_l.Value == pv_r.Value && pv_l.ImaginaryPart == pv_r.ImaginaryPart; } /* * Furthermore TODO: object comparison, pointer content comparison */ return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x); }
/// <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 NotEqualStrings() { EqualExpression expr = new EqualExpression(new ConstantExpression("foo"), new ConstantExpression("bar")); Assert.AreEqual(false, expr.Evaluate(null)); }
public virtual T VisitEqualExpression(EqualExpression equalExpression) { throw new NotImplementedException(); }
public Justification(EqualExpression expression) { m_expr = expression; m_ras = s_empty; }
public AbstractType Visit(EqualExpression x) { return(new PrimitiveType(DTokens.Bool)); }
IExpression CmpExpression(IBlockNode Scope = null) { var left = ShiftExpression(Scope); OperatorBasedExpression ae = null; // Equality Expressions if (laKind == Equal || laKind == NotEqual) ae = new EqualExpression(laKind == NotEqual); // Relational Expressions else if (RelationalOperators[laKind]) ae = new RelExpression(laKind); // Identity Expressions else if (laKind == Is || (laKind == Not && Peek(1).Kind == Is)) ae = new IdendityExpression(laKind == Not); // In Expressions else if (laKind == In || (laKind == Not && Peek(1).Kind == In)) ae = new InExpression(laKind == Not); else return left; LastParsedObject = ae; // Skip possible !-Token if (laKind == Not) Step(); // Skip operator Step(); ae.LeftOperand = left; ae.RightOperand = ShiftExpression(Scope); return ae; }
public void CompareRealOneWithIntegerOne() { EqualExpression expr = new EqualExpression(new ConstantExpression(1.0), new ConstantExpression(1)); Assert.AreEqual(true, expr.Evaluate(null)); }
public virtual TResult Visit(EqualExpression expression, TEnvironment environment) { return(this.Visit((BinaryExpression)expression, environment)); }
ISemantic E(EqualExpression x, ISemantic lValue =null, ISemantic rValue = null) { var l = TryGetValue(lValue ?? E(x.LeftOperand)); var r = TryGetValue(rValue ?? E(x.RightOperand)); var isEq = SymbolValueComparer.IsEqual(l, r); return new PrimitiveValue(x.OperatorToken == DTokens.Equal ? isEq : !isEq, x); }