public void InvalidFilterExpressionsTest()
        {
            IEnumerable <InvalidExpressionTestCase> testCases = new InvalidExpressionTestCase[]
            {
                new InvalidExpressionTestCase {
                    Expression = "", ExpectedErrorMessage = "Expression expected at position 0 in '$(Expression)'."
                },
            };

            testCases = testCases.Concat(InvalidExpressionTestCase.InvalidPrimitiveLiteralTestCases);
            testCases = testCases.Concat(InvalidExpressionTestCase.InvalidExpressionTestCases);

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                this.Assert.ExpectedException <ODataException>(
                    () => QueryTokenUtils.ParseQuery("Root", filter: testCase.Expression),
                    StringUtils.ResolveVariables(testCase.ExpectedErrorMessage, new Dictionary <string, string>()
                {
                    { "Expression", testCase.Expression }
                }),
                    "The filter parsing should have failed.");
            });
        }
Esempio n. 2
0
        public void FormatExpressionTest()
        {
            string[] values = new string[] { "json", "xml", "foo", "bar" };

            var testCases = values.Select(value =>
                                          new
            {
                Value = value,
            });

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                SyntacticTree actual =
                    QueryTokenUtils.ParseQuery("Root", format: testCase.Value);

                SyntacticTree expected = new SyntacticTree(
                    null,
                    new[] { "Root" },
                    null,
                    null,
                    null,
                    null,
                    null,
                    null,
                    null,
                    testCase.Value,
                    null);

                QueryTokenUtils.VerifySyntaxTreesAreEqual(expected, actual, this.Assert);
            });
        }
Esempio n. 3
0
        public void CountExpressionTest()
        {
            object[] values = new object[] { null, 0, 1, 2, 5, 11111, -2, 12.3, "Foo", -12.4m, 'c', (long)int.MaxValue + 1, (long)int.MinValue - 1, 2.3f, "(1)", "2 + 3", "int.MaxValue", "false", "true", "False", "True", "FaLSE", "trUE" };

            string           errorMessageTemplate = "Invalid value '{0}' for $count query option found. Valid values are '{1}'.";
            HashSet <string> correctValues        = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
            {
                "true", "false"
            };
            string correctValuesStr = string.Join(", ", correctValues.ToArray());
            var    testCases        = values.Select(value =>
                                                    new
            {
                Value = value == null ? null : value.ToString(),
                ExpectedErrorMessage = value == null || correctValues.Contains(value.ToString())
                        ? null
                        : string.Format(CultureInfo.InvariantCulture, errorMessageTemplate, value, correctValuesStr).Replace('+', ' ')    // URI all + will be replace by space
            });

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                this.Assert.ExpectedException <ODataException>(
                    () =>
                {
                    SyntacticTree actual =
                        QueryTokenUtils.ParseQuery("Root", count: testCase.Value);

                    bool?countQuery = null;

                    if (testCase.Value != null)
                    {
                        bool countValue;
                        bool.TryParse(testCase.Value, out countValue);

                        countQuery = countValue;
                    }

                    SyntacticTree expected = new SyntacticTree(
                        null,
                        new[] { "Root" },
                        null,
                        null,
                        null,
                        null,
                        null,
                        null,
                        countQuery,
                        null,
                        null);

                    QueryTokenUtils.VerifySyntaxTreesAreEqual(expected, actual, this.Assert);
                },
                    testCase.ExpectedErrorMessage,
                    null);
            });
        }
Esempio n. 4
0
        public void SegmentTests()
        {
            var testCases = new []
            {
                new{
                    Uri           = "/Customers",
                    ExpectedNodes = new StartPathToken("Customers", null, null)
                },
                new{
                    Uri           = "/Customers()",
                    ExpectedNodes = new StartPathToken("Customers", null, new NamedValue[0])
                },
                new{
                    Uri           = "/Customers/$count",
                    ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Count, new StartPathToken("Customers", null, null))
                },
                new{
                    Uri           = "/$metadata/Foo",
                    ExpectedNodes = new StartPathToken("Foo", new KeywordSegmentToken(KeywordKind.Metadata, null), null)
                },
                new{
                    Uri           = "/Customers()/$count",
                    ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Count, new StartPathToken("Customers", null, new NamedValue[0]))
                },
                new{
                    Uri           = "/Customers()/$links/Orders()",
                    ExpectedNodes = new StartPathToken(
                        "Orders",
                        new KeywordSegmentToken(KeywordKind.Links, new StartPathToken("Customers", null, new NamedValue[0])), new NamedValue[0])
                },
                new{
                    Uri           = "/Customers/$batch",
                    ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Batch, new StartPathToken("Customers", null, null))
                },
                new{
                    Uri           = "/Orders/$value",
                    ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Value, new StartPathToken("Orders", null, null))
                },
                new{
                    Uri           = "/",
                    ExpectedNodes = new StartPathToken("", null, null)
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
                    testCase.ExpectedNodes,
                    QueryTokenUtils.ParseQuery(testCase.Uri).Path,
                    this.Assert));
        }
 public void FilterExpressionTest()
 {
     CombinatorialEngineProvider.RunCombinations(
         ExpressionTestCase.PrimitiveLiteralTestCases()
         .Concat(ExpressionTestCase.BinaryOperatorTestCases())
         .Concat(ExpressionTestCase.UnaryOperatorTestCases())
         .Concat(ExpressionTestCase.PropertyAccessTestCases(ExpressionTestCase.PropertyAccessNames))
         .Concat(ExpressionTestCase.ParenthesisTestCases())
         .Concat(ExpressionTestCase.FunctionCallTestCases()),
         testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
             testCase.ExpectedToken,
             QueryTokenUtils.ParseQuery("Root", filter: testCase.Expression).Filter,
             this.Assert));
 }
Esempio n. 6
0
 public void InvalidSingleKeyValueTest()
 {
     this.CombinatorialEngineProvider.RunCombinations(
         InvalidExpressionTestCase.InvalidPrimitiveLiteralTestCases,
         (testCase) =>
     {
         this.Assert.ExpectedException <ODataException>(
             () => QueryTokenUtils.ParseQuery("/Customers(" + testCase.Expression + ")"),
             StringUtils.ResolveVariables(testCase.ExpectedErrorMessage, new Dictionary <string, string>()
         {
             { "Expression", testCase.Expression }
         }),
             "Parser should fail to parse a key value.");
     });
 }
Esempio n. 7
0
        public void ExpandExpressionTest()
        {
            IEnumerable <ExpressionTestCase> expressionTestCases = ExpressionTestCase.PrimitiveLiteralTestCases()
                                                                   .Concat(ExpressionTestCase.BinaryOperatorTestCases())
                                                                   .Concat(ExpressionTestCase.UnaryOperatorTestCases())
                                                                   .Concat(ExpressionTestCase.PropertyAccessTestCases(ExpressionTestCase.PropertyAccessNames))
                                                                   .Concat(ExpressionTestCase.ParenthesisTestCases())
                                                                   .Concat(ExpressionTestCase.FunctionCallTestCases());

            var testCases = expressionTestCases.Select(tc => new ExpandTestCase()
            {
                Expand = tc.Expression,
                ExpectedExpandToken = new ExpandToken(new QueryToken[] { tc.ExpectedToken })
            });

            // All expressions
            testCases.Concat(new ExpandTestCase[] { new ExpandTestCase()
                                                    {
                                                        Expand = string.Join(", ", expressionTestCases.Select(tc => tc.Expression).ToArray()),
                                                        ExpectedExpandToken = new ExpandToken(expressionTestCases.Select(tc => tc.ExpectedToken))
                                                    } });

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                SyntacticTree actual   = QueryTokenUtils.ParseQuery("Root", expand: testCase.Expand);
                SyntacticTree expected = new SyntacticTree(
                    new SegmentToken("Root", null, null),
                    null,
                    null,
                    null,
                    testCase.ExpectedExpandToken,
                    null,
                    null,
                    null,
                    null,
                    null);

                QueryTokenUtils.VerifySyntaxTreesAreEqual(
                    expected,
                    actual,
                    this.Assert);
            });
        }
Esempio n. 8
0
        public void InvalidOrderByExpressionsTest()
        {
            IEnumerable <InvalidExpressionTestCase> testCases = new InvalidExpressionTestCase[]
            {
                new InvalidExpressionTestCase {
                    Expression = "", ExpectedErrorMessage = "Expression expected at position 0 in '$(Expression)'."
                },

                new InvalidExpressionTestCase {
                    Expression = "foo,", ExpectedErrorMessage = "Expression expected at position 4 in '$(Expression)'."
                },
                new InvalidExpressionTestCase {
                    Expression = ",foo", ExpectedErrorMessage = "Expression expected at position 0 in '$(Expression)'."
                },
                new InvalidExpressionTestCase {
                    Expression = "foo asc,", ExpectedErrorMessage = "Expression expected at position 8 in '$(Expression)'."
                },
                new InvalidExpressionTestCase {
                    Expression = "foo desc,", ExpectedErrorMessage = "Expression expected at position 9 in '$(Expression)'."
                },
                new InvalidExpressionTestCase {
                    Expression = "foo asc desc", ExpectedErrorMessage = "Syntax error at position 12 in '$(Expression)'."
                },
                new InvalidExpressionTestCase {
                    Expression = "foo ASC", ExpectedErrorMessage = "Syntax error at position 7 in '$(Expression)'."
                },
            };

            testCases = testCases.Concat(InvalidExpressionTestCase.InvalidPrimitiveLiteralTestCases);

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                this.Assert.ExpectedException <ODataException>(
                    () => QueryTokenUtils.ParseQuery("Root", orderby: testCase.Expression),
                    StringUtils.ResolveVariables(testCase.ExpectedErrorMessage, new Dictionary <string, string>()
                {
                    { "Expression", testCase.Expression }
                }),
                    "The orderby parsing should have failed.");
            });
        }
Esempio n. 9
0
        public void SelectExpressionTest()
        {
            IEnumerable <SelectExpressionTestCase> expressionTestCases = SelectExpressionTestCase.SelectPropertyAccessTestCases(ExpressionTestCase.PropertyAccessNames);

            var testCases = expressionTestCases.Select(tc => new SelectTestCase()
            {
                Select = tc.Expression,
                ExpectedSelectToken = new SelectToken(new PathSegmentToken[] { tc.ExpectedToken })
            });

            // All expressions
            testCases.Concat(new SelectTestCase[] { new SelectTestCase()
                                                    {
                                                        Select = string.Join(", ", expressionTestCases.Select(tc => tc.Expression).ToArray()),
                                                        ExpectedSelectToken = new SelectToken(expressionTestCases.Select(tc => tc.ExpectedToken))
                                                    } });

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                SyntacticTree actual   = QueryTokenUtils.ParseQuery("Root", select: testCase.Select);
                SyntacticTree expected = new SyntacticTree(
                    new StartPathToken("Root", null, null),
                    null,
                    null,
                    testCase.ExpectedSelectToken,
                    null,
                    null,
                    null,
                    null,
                    null,
                    null);

                QueryTokenUtils.VerifySyntaxTreesAreEqual(
                    expected,
                    actual,
                    this.Assert);
            });
        }
Esempio n. 10
0
        public void UriVariationExpressionsTest()
        {
            IEnumerable <ExpressionTestCase> testCases = new ExpressionTestCase[]
            {
                // Uri query where + instead of space is in Uri text
                new ExpressionTestCase {
                    Expression = "1+lt+2+and+true+ne+false", ExpectedToken = new BinaryOperatorToken(
                        BinaryOperatorKind.And,
                        new BinaryOperatorToken(BinaryOperatorKind.LessThan, new LiteralToken(1), new LiteralToken(2)),
                        new BinaryOperatorToken(BinaryOperatorKind.NotEqual, new LiteralToken(true), new LiteralToken(false)))
                }
            };

            CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                QueryTokenUtils.VerifyQueryTokensAreEqual(
                    testCase.ExpectedToken,
                    QueryTokenUtils.ParseQuery("Root", filter: testCase.Expression).Filter,
                    this.Assert);
            });
        }
Esempio n. 11
0
        public void OrderByExpressionTest()
        {
            IEnumerable <ExpressionTestCase> expressionTestCases = ExpressionTestCase.PrimitiveLiteralTestCases()
                                                                   .Concat(ExpressionTestCase.BinaryOperatorTestCases())
                                                                   .Concat(ExpressionTestCase.UnaryOperatorTestCases())
                                                                   .Concat(ExpressionTestCase.PropertyAccessTestCases(ExpressionTestCase.PropertyAccessNames))
                                                                   .Concat(ExpressionTestCase.ParenthesisTestCases())
                                                                   .Concat(ExpressionTestCase.FunctionCallTestCases());

            // Use filter expressions first without anything
            var filterWithNoDirection = expressionTestCases.Select(tc => new OrderByTestCase()
            {
                OrderBy = tc.Expression,
                ExpectedOrderByTokens = new OrderByToken[] { new OrderByToken(tc.ExpectedToken, OrderByDirection.Ascending) }
            });

            // Use filter expressions with asc
            var filterWithAscending = expressionTestCases.Select(tc => new OrderByTestCase()
            {
                OrderBy = tc.Expression + " asc",
                ExpectedOrderByTokens = new OrderByToken[] { new OrderByToken(tc.ExpectedToken, OrderByDirection.Ascending) }
            });

            // Use filter expressions with desc
            var filterWithDescending = expressionTestCases.Select(tc => new OrderByTestCase()
            {
                OrderBy = tc.Expression + " desc",
                ExpectedOrderByTokens = new OrderByToken[] { new OrderByToken(tc.ExpectedToken, OrderByDirection.Descending) }
            });

            // And now some order by specific cases with multiple orderbys
            var orderByTestCases = ExpressionTestCase.VariousExpressions().ToList().Variations(3).Select(tc =>
                                                                                                         new OrderByTestCase
            {
                OrderBy = string.Join(",", tc.Select((t, index) => t.Expression + ((index % 3 == 0) ? "" : ((index % 3 == 1) ? " asc" : " desc"))).ToArray()),
                ExpectedOrderByTokens = tc.Select((t, index) => new OrderByToken(
                                                      t.ExpectedToken,
                                                      (index % 3 == 2) ? OrderByDirection.Descending : OrderByDirection.Ascending)).ToArray()
            });

            CombinatorialEngineProvider.RunCombinations(
                filterWithNoDirection
                .Concat(filterWithAscending)
                .Concat(filterWithDescending)
                .Concat(orderByTestCases),
                (testCase) =>
            {
                SyntacticTree actual   = QueryTokenUtils.ParseQuery("Root", orderby: testCase.OrderBy);
                SyntacticTree expected = new SyntacticTree(
                    null,
                    new[] { "Root" },
                    null,
                    testCase.ExpectedOrderByTokens,
                    null,
                    null,
                    null,
                    null,
                    null,
                    null,
                    null);

                QueryTokenUtils.VerifySyntaxTreesAreEqual(
                    expected,
                    actual,
                    this.Assert);
            });
        }
Esempio n. 12
0
        public void InvalidKeyValuesTest()
        {
            var testCases = new[]
            {
                new {
                    KeyValues            = "(",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(42",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(42,",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(Key)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(Key,0)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(Key=Key)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "\t(  Key = eq)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(eq)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "\t(  gt )",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "\t(()",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(-INFI)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(INFI)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(-NaNn)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
                new {
                    KeyValues            = "(NaNn)",
                    ExpectedErrorMessage = "Bad Request: there was an error in the query syntax."
                },
            };

            var keyValuesContainers = new string[]
            {
                "/Customers{0}",
                "/Customers{0}/Orders",
                "/Customers(0)/Orders{0}",
                "/Customers(0)/$links/Orders{0}"
            };

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                keyValuesContainers,
                (testCase, keyValuesContainer) =>
            {
                this.Assert.ExpectedException <ODataException>(
                    () => QueryTokenUtils.ParseQuery(string.Format(keyValuesContainer, testCase.KeyValues)),
                    testCase.ExpectedErrorMessage,
                    "Parser should fail to parse a key value.");
            });
        }
Esempio n. 13
0
        public void KeyValuesTest()
        {
            IEnumerable <KeyValuesTestCase> testCases = new[]
            {
                new KeyValuesTestCase {
                    KeyValues         = "()",
                    ExpectedKeyValues = new NamedValue[0]
                },
                new KeyValuesTestCase {
                    KeyValues         = "(0)",
                    ExpectedKeyValues = new [] { new NamedValue(null, new LiteralToken(0)) }
                },
                new KeyValuesTestCase {
                    KeyValues         = "(0,1)",
                    ExpectedKeyValues = new [] {
                        new NamedValue(null, new LiteralToken(0)),
                        new NamedValue(null, new LiteralToken(1))
                    }
                },
                new KeyValuesTestCase {
                    KeyValues         = "(Key='some')",
                    ExpectedKeyValues = new [] {
                        new NamedValue("Key", new LiteralToken("some")),
                    }
                },
                new KeyValuesTestCase {
                    KeyValues         = "(Key=datetime'2010-12-09T14:10:20')",
                    ExpectedKeyValues = new [] {
                        new NamedValue("Key", new LiteralToken(new DateTime(2010, 12, 9, 14, 10, 20)))
                    }
                },
                new KeyValuesTestCase {
                    KeyValues         = "(Key1=42.42,  Key2=42f)",
                    ExpectedKeyValues = new [] {
                        new NamedValue("Key1", new LiteralToken((double)42.42)),
                        new NamedValue("Key2", new LiteralToken((Single)42))
                    }
                },
                new KeyValuesTestCase {
                    KeyValues         = "(Key=1,Key=2)",
                    ExpectedKeyValues = new [] {
                        new NamedValue("Key", new LiteralToken(1)),
                        new NamedValue("Key", new LiteralToken(2))
                    }
                },
            };

            testCases.Concat(ExpressionTestCase.PrimitiveLiteralTestCases().Select(tc =>
                                                                                   new KeyValuesTestCase()
            {
                KeyValues         = "(" + tc.Expression + ")",
                ExpectedKeyValues = new[] { new NamedValue(null, (LiteralToken)tc.ExpectedToken) }
            }));

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
                    new StartPathToken("Customers", null, testCase.ExpectedKeyValues),
                    QueryTokenUtils.ParseQuery("/Customers" + testCase.KeyValues).Path,
                    this.Assert));
        }
Esempio n. 14
0
        void RunTest(bool includeSpaceAroundSymbols)
        {
            var testCases = new[]
            {
                new
                {
                    QueryOptions         = (List <KeyValuePair <string, string> >)null,
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$filter", "3 eq 2")
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("CustomValue", "null")
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("null", "CustomValue")
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$custom", "2")
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$a", "1"),
                        new KeyValuePair <string, string>("$b", "2"),
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("a", "1"),
                        new KeyValuePair <string, string>("$filter", "3 eq 2"),
                        new KeyValuePair <string, string>("b", "2"),
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$a", "1"),
                        new KeyValuePair <string, string>("$filter", "3 eq 2"),
                        new KeyValuePair <string, string>("$b", "2"),
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("a", "1"),
                        new KeyValuePair <string, string>("b", "2"),
                        new KeyValuePair <string, string>("a", "2"),
                        new KeyValuePair <string, string>("b", "4"),
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$filter", "3 eq 2"),
                        new KeyValuePair <string, string>("$filter", "2 eq 3"),
                        new KeyValuePair <string, string>("$b", "2"),
                    },
                    ExpectedErrorMessage = "Query option '$filter' was specified more than once, but it must be specified at most once.",
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$select", "Name")
                    },
                    ExpectedErrorMessage = (string)null,
                },
                new
                {
                    QueryOptions = new List <KeyValuePair <string, string> >()
                    {
                        new KeyValuePair <string, string>("$expand", "Products")
                    },
                    ExpectedErrorMessage = (string)null,
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                testCases,
                (testCase) =>
            {
                this.Assert.ExpectedException <ODataException>(
                    () =>
                {
                    SyntacticTree actual = QueryTokenUtils.ParseQuery("Root", testCase.QueryOptions, includeSpaceAroundSymbols);
                    List <CustomQueryOptionToken> options = QueryTokenUtils.NormalizeAndRemoveBuiltInQueryOptions(testCase.QueryOptions);
                    options = options != null && options.Count == 0 ? null : options;

                    SyntacticTree expected = new SyntacticTree(
                        null,
                        new[] { "Feed" },
                        actual.Filter,
                        actual.OrderByTokens,
                        null,
                        null,
                        actual.Skip,
                        null,
                        null,
                        null,
                        options);

                    QueryTokenUtils.VerifySyntaxTreesAreEqual(expected, actual, this.Assert);
                },
                    testCase.ExpectedErrorMessage,
                    null);
            });
        }