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)); }
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); }); }
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); }); }
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)); }