Exemple #1
0
        public void PromotesBinaryOperations(string input)
        {
            var visitor = new ExpressionFactoryVisitor();
            var expr    = visitor.Visit(FilterSyntaxFactory.ParseExpression(input));

            Assert.NotNull(expr);
        }
Exemple #2
0
        public void Convert(string input)
        {
            var visitor = new ExpressionFactoryVisitor();
            var expr    = visitor.Visit(FilterSyntaxFactory.ParseExpression(input));

            Assert.NotNull(expr);
        }
Exemple #3
0
        public void NoImplicitConversionToBool()
        {
            var syntaxNode = FilterSyntaxFactory.ParseExpression("Id & 1");

            var ex = Assert.Throws <InvalidOperationException>(() => ExpressionFactoryVisitor.Convert(syntaxNode));

            Assert.Contains("expression is not boolean", ex.Message, StringComparison.InvariantCultureIgnoreCase);
        }
Exemple #4
0
        public void ForbidsIncompatibleOperands(string input)
        {
            var visitor    = new ExpressionFactoryVisitor();
            var syntaxNode = FilterSyntaxFactory.ParseExpression(input);

            var ex = Assert.Throws <ArgumentException>(() => visitor.Visit(syntaxNode));

            Assert.Contains("cannot compare incompatible operand types", ex.Message, StringComparison.InvariantCultureIgnoreCase);
        }
Exemple #5
0
        public void HexLiteral()
        {
            var visitor = new ExpressionFactoryVisitor();
            var expr    = visitor.Visit(FilterSyntaxFactory.ParseExpression("Id == 0x12"));

            Assert.NotNull(expr);
            Assert.Equal(ExpressionType.Equal, expr.NodeType);
            var binExpr = (BinaryExpression)expr;

            Assert.Equal(TraceLogFilterBuilder.Instance.Id, binExpr.Left);
            var valueExpr = Assert.IsType <ConstantExpression>(binExpr.Right);

            Assert.Equal((ushort)0x12, valueExpr.Value);
        }
Exemple #6
0
        public void Mask()
        {
            var expr = ExpressionFactoryVisitor.Convert(FilterSyntaxFactory.ParseExpression("(Id & 0x12) != 0"));

            Assert.NotNull(expr);
            Assert.Equal(ExpressionType.NotEqual, expr.NodeType);
            var cmpExpr  = (BinaryExpression)expr;
            var zeroExpr = Assert.IsType <ConstantExpression>(cmpExpr.Right);

            Assert.Equal((ushort)0, zeroExpr.Value);
            Assert.Equal(ExpressionType.And, cmpExpr.Left.NodeType);
            var andExpr = (BinaryExpression)cmpExpr.Left;

            Assert.Equal(TraceLogFilterBuilder.Instance.Id, andExpr.Left);
            var valueExpr = Assert.IsType <ConstantExpression>(andExpr.Right);

            Assert.Equal((ushort)0x12, valueExpr.Value);
            Assert.Equal(typeof(bool), expr.Type);
        }