Пример #1
0
        public void TokensWithTruthyElementAccess_Parse_ReturnsCorrectExpression()
        {
            string input = "@.items >= 3 || @.b[123]";
            IReadOnlyList <FilterExpressionToken> tokens = FilterExpressionTokenizer.Tokenize(input);
            FilterSubExpression expr = FilterParser.Parse(tokens);

            Assert.IsType <LogicalFilterSubExpression>(expr);
            LogicalFilterSubExpression logical = expr as LogicalFilterSubExpression;

            // @.items > 3
            Assert.IsType <ComparisonFilterSubExpression>(logical.LeftSide);
            ComparisonFilterSubExpression left = logical.LeftSide as ComparisonFilterSubExpression;

            Assert.True(left.IsGreaterOrEqual);
            Assert.True(left.LeftSide is PropertyFilterSubExpression p1 && p1.PropertyChain.Length == 1 && p1.PropertyChain[0] == "items");
            Assert.True(left.RightSide is NumberConstantFilterSubExpression n1 && n1.Value == 3.0);

            // @.b[0]
            Assert.IsType <TruthyFilterSubExpression>(logical.RightSide);
            TruthyFilterSubExpression tr = logical.RightSide as TruthyFilterSubExpression;

            Assert.IsType <ArrayAccessFilterSubExpression>(tr.Expression);
            ArrayAccessFilterSubExpression ar = tr.Expression as ArrayAccessFilterSubExpression;

            Assert.True(ar.ExactElementsAccess != null && ar.ExactElementsAccess.Length == 1 && ar.ExactElementsAccess[0] == 123);
        }
Пример #2
0
        public void TokensWithArray_Parse_ReturnsCorrectExpression()
        {
            string input = "@.items[2] > 3";
            IReadOnlyList <FilterExpressionToken> tokens = FilterExpressionTokenizer.Tokenize(input);
            FilterSubExpression expr = FilterParser.Parse(tokens);

            Assert.IsType <ComparisonFilterSubExpression>(expr);
            ComparisonFilterSubExpression comp = expr as ComparisonFilterSubExpression;

            Assert.IsType <ArrayAccessFilterSubExpression>(comp.LeftSide);
            Assert.True((comp.RightSide as NumberConstantFilterSubExpression)?.Value == 3.0);

            ArrayAccessFilterSubExpression aa = comp.LeftSide as ArrayAccessFilterSubExpression;

            Assert.True(aa.ExactElementsAccess?.Length == 1 && aa.ExactElementsAccess[0] == 2);
            Assert.True(aa.ExecutedOn is PropertyFilterSubExpression p && p.PropertyChain.Length == 1 && p.PropertyChain[0] == "items");
        }
Пример #3
0
        public void TokensWithMethodCallOnArray_Parse_ReturnsCorrectExpression()
        {
            string input = "@.items.next[-1].contains(2.123)";
            IReadOnlyList <FilterExpressionToken> tokens = FilterExpressionTokenizer.Tokenize(input);
            FilterSubExpression expr = FilterParser.Parse(tokens);

            Assert.IsType <MethodCallFilterSubExpression>(expr);
            MethodCallFilterSubExpression mc = expr as MethodCallFilterSubExpression;

            Assert.Equal(1, mc.Arguments.Count);
            Assert.Equal(2.123, (mc.Arguments[0] as NumberConstantFilterSubExpression)?.Value ?? double.MinValue, 8);

            Assert.IsType <ArrayAccessFilterSubExpression>(mc.CalledOnExpression);
            ArrayAccessFilterSubExpression aa = mc.CalledOnExpression as ArrayAccessFilterSubExpression;

            Assert.Equal(-1, aa.ExactElementsAccess.Single());

            Assert.IsType <PropertyFilterSubExpression>(aa.ExecutedOn);
            PropertyFilterSubExpression prop = aa.ExecutedOn as PropertyFilterSubExpression;

            Assert.Equal(2, prop.PropertyChain.Length);
            Assert.Equal("items", prop.PropertyChain[0]);
            Assert.Equal("next", prop.PropertyChain[1]);
        }