← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to external/nrefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
ImportĀ upstreamĀ versionĀ 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
external/nrefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs
 
1
ļ»æ// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.IO;
 
6
using System.Linq;
 
7
 
 
8
using ICSharpCode.NRefactory.VB.Ast;
 
9
using ICSharpCode.NRefactory.VB.Parser;
 
10
using NUnit.Framework;
 
11
 
 
12
namespace ICSharpCode.NRefactory.VB.Tests.Ast
 
13
{
 
14
        [TestFixture]
 
15
        public class QueryExpressionTests
 
16
        {
 
17
                void RunTest(string expression, int expectedCount, Action<QueryExpression> constraint, params Type[] expectedTypes)
 
18
                {
 
19
                        var expr = ParseUtil.ParseExpression<QueryExpression>(expression);
 
20
                        
 
21
                        Assert.AreEqual(expectedCount, expr.Clauses.Count);
 
22
                        
 
23
                        for (int i = 0; i < expectedTypes.Length; i++) {
 
24
                                Assert.IsTrue(expectedTypes[i] == expr.Clauses[i].GetType());
 
25
                        }
 
26
                        
 
27
                        constraint(expr);
 
28
                }
 
29
                
 
30
                [Test]
 
31
                public void SimpleQueryTest()
 
32
                {
 
33
                        RunTest("From o In db.Orders Select o.OrderID", 2,
 
34
                                expr => {
 
35
                                        var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
36
                                        var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
 
37
                                        
 
38
                                        Assert.AreEqual(1, fromClause.Sources.Count);
 
39
                                        
 
40
                                        var var1 = fromClause.Sources.First();
 
41
                                        
 
42
                                        Assert.AreEqual("o", var1.Identifier);
 
43
                                        Assert.IsTrue(var1.Expression is MemberReferenceExpression);
 
44
                                        var inExpr = var1.Expression as MemberReferenceExpression;
 
45
                                        Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db");
 
46
                                        
 
47
                                        Assert.AreEqual(1, selectClause.Variables.Count);
 
48
                                        Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression);
 
49
                                        var member = selectClause.Variables[0].Expression as MemberReferenceExpression;
 
50
                                        
 
51
                                        Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o");
 
52
                                },
 
53
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause)
 
54
                               );
 
55
                }
 
56
                
 
57
                [Test]
 
58
                public void SkipTakeQueryTest()
 
59
                {
 
60
                        RunTest("From o In db.Orders Select o.OrderID Skip 10 Take 5", 4,
 
61
                                expr => {
 
62
                                        var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
63
                                        var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
 
64
                                        var skipClause = expr.Clauses[2] as QueryExpressionPartitionVBClause;
 
65
                                        var takeClause = expr.Clauses[3] as QueryExpressionPartitionVBClause;
 
66
                                        
 
67
                                        Assert.AreEqual(1, fromClause.Sources.Count);
 
68
                                        
 
69
                                        var var1 = fromClause.Sources.First();
 
70
                                        
 
71
                                        Assert.AreEqual("o", var1.Identifier);
 
72
                                        Assert.IsTrue(var1.Expression is MemberReferenceExpression);
 
73
                                        var inExpr = var1.Expression as MemberReferenceExpression;
 
74
                                        Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db");
 
75
                                        
 
76
                                        Assert.AreEqual(1, selectClause.Variables.Count);
 
77
                                        Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression);
 
78
                                        var member = selectClause.Variables[0].Expression as MemberReferenceExpression;
 
79
                                        
 
80
                                        Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o");
 
81
                                        
 
82
                                        Assert.AreEqual(QueryExpressionPartitionType.Skip, skipClause.PartitionType);
 
83
                                        Assert.IsTrue(skipClause.Expression is PrimitiveExpression &&
 
84
                                                      (skipClause.Expression as PrimitiveExpression).StringValue == "10");
 
85
                                        
 
86
                                        Assert.AreEqual(QueryExpressionPartitionType.Take, takeClause.PartitionType);
 
87
                                        Assert.IsTrue(takeClause.Expression is PrimitiveExpression &&
 
88
                                                      (takeClause.Expression as PrimitiveExpression).StringValue == "5");
 
89
                                },
 
90
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause),
 
91
                                typeof(QueryExpressionPartitionVBClause), typeof(QueryExpressionPartitionVBClause)
 
92
                               );
 
93
                }
 
94
                
 
95
                [Test]
 
96
                public void SkipWhileTakeWhileQueryTest()
 
97
                {
 
98
                        RunTest("From o In db.Orders Select o.OrderID Skip While o.OrderId > 2 Take While o.OrderId < 5", 4,
 
99
                                expr => {
 
100
                                        var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
101
                                        var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
 
102
                                        var skipClause = expr.Clauses[2] as QueryExpressionPartitionVBClause;
 
103
                                        var takeClause = expr.Clauses[3] as QueryExpressionPartitionVBClause;
 
104
                                        
 
105
                                        Assert.AreEqual(1, fromClause.Sources.Count);
 
106
                                        
 
107
                                        var var1 = fromClause.Sources.First();
 
108
                                        
 
109
                                        Assert.AreEqual("o", var1.Identifier);
 
110
                                        Assert.IsTrue(var1.Expression is MemberReferenceExpression);
 
111
                                        var inExpr = var1.Expression as MemberReferenceExpression;
 
112
                                        Assert.IsTrue(inExpr.MemberName == "Orders" && inExpr.TargetObject is IdentifierExpression && (inExpr.TargetObject as IdentifierExpression).Identifier == "db");
 
113
                                        
 
114
                                        Assert.AreEqual(1, selectClause.Variables.Count);
 
115
                                        Assert.IsTrue(selectClause.Variables[0].Expression is MemberReferenceExpression);
 
116
                                        var member = selectClause.Variables[0].Expression as MemberReferenceExpression;
 
117
                                        
 
118
                                        Assert.IsTrue(member.MemberName == "OrderID" && member.TargetObject is IdentifierExpression && (member.TargetObject as IdentifierExpression).Identifier == "o");
 
119
                                        
 
120
                                        Assert.AreEqual(QueryExpressionPartitionType.SkipWhile, skipClause.PartitionType);
 
121
                                        Assert.IsTrue(skipClause.Expression is BinaryOperatorExpression);
 
122
                                        
 
123
                                        Assert.AreEqual(QueryExpressionPartitionType.TakeWhile, takeClause.PartitionType);
 
124
                                        Assert.IsTrue(takeClause.Expression is BinaryOperatorExpression);
 
125
                                },
 
126
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause),
 
127
                                typeof(QueryExpressionPartitionVBClause), typeof(QueryExpressionPartitionVBClause)
 
128
                               );
 
129
                }
 
130
                
 
131
                [Test]
 
132
                public void MultipleValuesSelectTest()
 
133
                {
 
134
                        RunTest(@"From i In list Select i, x2 = i^2",
 
135
                                2, expr => {
 
136
                                        var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
137
                                        var selectClause = expr.Clauses[1] as QueryExpressionSelectVBClause;
 
138
                                        
 
139
                                        Assert.AreEqual(1, fromClause.Sources.Count);
 
140
                                        
 
141
                                        var var1 = fromClause.Sources.First();
 
142
                                        
 
143
                                        Assert.AreEqual("i", var1.Identifier);
 
144
                                        Assert.IsTrue(var1.Expression is IdentifierExpression);
 
145
                                        Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list");
 
146
                                        
 
147
                                        Assert.AreEqual(2, selectClause.Variables.Count);
 
148
                                        
 
149
                                        var selectExpr1 = selectClause.Variables[0];
 
150
                                        var selectExpr2 = selectClause.Variables[1];
 
151
                                        
 
152
                                        Assert.IsEmpty(selectExpr1.Identifier);
 
153
                                        Assert.IsTrue(selectExpr1.Expression is IdentifierExpression &&
 
154
                                                      (selectExpr1.Expression as IdentifierExpression).Identifier == "i");
 
155
                                        
 
156
                                        Assert.AreEqual("x2", selectExpr2.Identifier);
 
157
                                        Assert.IsTrue(selectExpr2.Type.IsNull);
 
158
                                        Assert.IsTrue(selectExpr2.Expression is BinaryOperatorExpression);
 
159
                                        
 
160
                                        var binOp = selectExpr2.Expression as BinaryOperatorExpression;
 
161
                                        
 
162
                                        Assert.AreEqual(BinaryOperatorType.Power, binOp.Op);
 
163
                                        Assert.IsTrue(binOp.Left is IdentifierExpression && (binOp.Left as IdentifierExpression).Identifier == "i");
 
164
                                        Assert.IsTrue(binOp.Right is PrimitiveExpression && (binOp.Right as PrimitiveExpression).StringValue == "2");
 
165
                                },
 
166
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause)
 
167
                               );
 
168
                }
 
169
                
 
170
                [Test]
 
171
                public void GroupTest()
 
172
                {
 
173
                        Action<QueryExpression> constraint = expr => {
 
174
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
175
                                var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause;
 
176
                                var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause;
 
177
                                
 
178
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
179
                                
 
180
                                var fromVar1 = fromClause.Sources.First();
 
181
                                
 
182
                                Assert.AreEqual("p", fromVar1.Identifier);
 
183
                                Assert.IsTrue(fromVar1.Expression is IdentifierExpression);
 
184
                                Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "products");
 
185
                                
 
186
                                Assert.AreEqual(1, groupClause.GroupVariables.Count);
 
187
                                Assert.AreEqual(1, groupClause.ByVariables.Count);
 
188
                                Assert.AreEqual(1, groupClause.IntoVariables.Count);
 
189
                                
 
190
                                var gv = groupClause.GroupVariables.First();
 
191
                                var bv = groupClause.ByVariables.First();
 
192
                                var iv = groupClause.IntoVariables.First();
 
193
                                
 
194
                                Assert.IsTrue(gv.Expression is IdentifierExpression && (gv.Expression as IdentifierExpression).Identifier == "p");
 
195
                                Assert.IsTrue(bv.Expression is MemberReferenceExpression &&
 
196
                                              (bv.Expression as MemberReferenceExpression).MemberName == "Category");
 
197
                                Assert.IsTrue((bv.Expression as MemberReferenceExpression).TargetObject is IdentifierExpression &&
 
198
                                              ((bv.Expression as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "p");
 
199
                                Assert.IsTrue(iv.Expression is IdentifierExpression &&
 
200
                                              (iv.Expression as IdentifierExpression).Identifier == "Group");
 
201
                                
 
202
                                Assert.AreEqual(2, selectClause.Variables.Count);
 
203
                                
 
204
                                var var1 = selectClause.Variables.First();
 
205
                                var var2 = selectClause.Variables.Skip(1).First();
 
206
                                
 
207
                                Assert.IsTrue(var1.Expression is IdentifierExpression &&
 
208
                                              (var1.Expression as IdentifierExpression).Identifier == "Category");
 
209
                                Assert.IsTrue(var2.Expression is InvocationExpression &&
 
210
                                              (var2.Expression as InvocationExpression).TargetObject is MemberReferenceExpression &&
 
211
                                              ((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "Average" &&
 
212
                                              ((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression &&
 
213
                                              (((var2.Expression as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "Group");
 
214
                        };
 
215
                        
 
216
                        RunTest(@"From p In products _
 
217
            Group p By p.Category Into Group _
 
218
            Select Category, AveragePrice = Group.Average(Function(p) p.UnitPrice)", 3, constraint,
 
219
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionSelectVBClause));
 
220
                }
 
221
                
 
222
                [Test]
 
223
                public void LetTest()
 
224
                {
 
225
                        Action<QueryExpression> constraint = expr => {
 
226
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
227
                                var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause;
 
228
                                var letClause = expr.Clauses[2] as QueryExpressionLetClause;
 
229
                                var selectClause = expr.Clauses[3] as QueryExpressionSelectVBClause;
 
230
                                
 
231
                                // From
 
232
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
233
                                
 
234
                                var fromVar1 = fromClause.Sources.First();
 
235
                                
 
236
                                Assert.AreEqual("p", fromVar1.Identifier);
 
237
                                Assert.IsTrue(fromVar1.Expression is IdentifierExpression);
 
238
                                Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "products");
 
239
                                
 
240
                                // Group By Into
 
241
                                Assert.AreEqual(1, groupClause.GroupVariables.Count);
 
242
                                Assert.AreEqual(1, groupClause.ByVariables.Count);
 
243
                                Assert.AreEqual(1, groupClause.IntoVariables.Count);
 
244
                                
 
245
                                var gv = groupClause.GroupVariables.First();
 
246
                                var bv = groupClause.ByVariables.First();
 
247
                                var iv = groupClause.IntoVariables.First();
 
248
                                
 
249
                                Assert.IsTrue(gv.Expression is IdentifierExpression && (gv.Expression as IdentifierExpression).Identifier == "p");
 
250
                                CheckMemberReferenceExpression(bv.Expression, "Category", "p");
 
251
                                Assert.IsTrue(iv.Expression is IdentifierExpression &&
 
252
                                              (iv.Expression as IdentifierExpression).Identifier == "Group");
 
253
                                
 
254
                                // Let
 
255
                                Assert.AreEqual(1, letClause.Variables.Count);
 
256
                                
 
257
                                var letVariable = letClause.Variables.First();
 
258
                                
 
259
                                Assert.AreEqual("minPrice", letVariable.Identifier);
 
260
                                Assert.IsTrue(letVariable.Expression is InvocationExpression);
 
261
                                CheckMemberReferenceExpression((letVariable.Expression as InvocationExpression).TargetObject, "Min", "Group");
 
262
 
 
263
                                // Select
 
264
                                Assert.AreEqual(2, selectClause.Variables.Count);
 
265
                                
 
266
                                var var1 = selectClause.Variables.First();
 
267
                                var var2 = selectClause.Variables.Skip(1).First();
 
268
                                
 
269
                                Assert.IsTrue(var1.Expression is IdentifierExpression &&
 
270
                                              (var1.Expression as IdentifierExpression).Identifier == "Category");
 
271
                                Assert.IsTrue(var2.Expression is InvocationExpression);
 
272
                                CheckMemberReferenceExpression((var2.Expression as InvocationExpression).TargetObject, "Where", "Group");
 
273
                        };
 
274
                        
 
275
                        RunTest(@"From p In products _
 
276
            Group p By p.Category Into Group _
 
277
            Let minPrice = Group.Min(Function(p) p.UnitPrice) _
 
278
            Select Category, CheapestProducts = Group.Where(Function(p) p.UnitPrice = minPrice)", 4, constraint,
 
279
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionLetClause), typeof(QueryExpressionSelectVBClause));
 
280
                }
 
281
                
 
282
                [Test]
 
283
                public void CrossJoinTest()
 
284
                {
 
285
                        Action<QueryExpression> constraint = expr => {
 
286
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
287
                                var joinClause = expr.Clauses[1] as QueryExpressionJoinVBClause;
 
288
                                var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause;
 
289
                                
 
290
                                // From
 
291
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
292
                                
 
293
                                var fromVar1 = fromClause.Sources.First();
 
294
                                
 
295
                                Assert.AreEqual("c", fromVar1.Identifier);
 
296
                                Assert.IsTrue(fromVar1.Expression is IdentifierExpression);
 
297
                                Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "categories");
 
298
                                
 
299
                                // Join In On Equals
 
300
                                var inClause = joinClause.JoinVariable as CollectionRangeVariable;
 
301
                                
 
302
                                Assert.AreEqual("p", inClause.Identifier);
 
303
                                Assert.IsTrue(inClause.Expression is IdentifierExpression &&
 
304
                                              (inClause.Expression as IdentifierExpression).Identifier == "products");
 
305
                                
 
306
                                Assert.IsTrue(joinClause.SubJoin.IsNull);
 
307
                                
 
308
                                Assert.AreEqual(1, joinClause.Conditions.Count);
 
309
                                
 
310
                                var condition1 = joinClause.Conditions.First();
 
311
                                
 
312
                                Assert.IsTrue(condition1.LeftSide is IdentifierExpression && (condition1.LeftSide as IdentifierExpression).Identifier == "c");
 
313
                                
 
314
                                CheckMemberReferenceExpression(condition1.RightSide, "Category", "p");
 
315
                                
 
316
                                // Select
 
317
                                Assert.AreEqual(2, selectClause.Variables.Count);
 
318
                                
 
319
                                var var1 = selectClause.Variables.First();
 
320
                                var var2 = selectClause.Variables.Skip(1).First();
 
321
                                
 
322
                                Assert.AreEqual("Category", var1.Identifier);
 
323
                                Assert.IsEmpty(var2.Identifier);
 
324
                                
 
325
                                Assert.IsTrue(var1.Expression is IdentifierExpression &&
 
326
                                              (var1.Expression as IdentifierExpression).Identifier == "c");
 
327
                                CheckMemberReferenceExpression(var2.Expression, "ProductName", "p");
 
328
                        };
 
329
                        
 
330
                        RunTest(@"From c In categories _
 
331
                Join p In products On c Equals p.Category _
 
332
                Select Category = c, p.ProductName", 3, constraint,
 
333
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionJoinVBClause), typeof(QueryExpressionSelectVBClause));
 
334
                }
 
335
                
 
336
                [Test]
 
337
                public void OrderByTest()
 
338
                {
 
339
                        Action<QueryExpression> constraint = expr => {
 
340
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
341
                                var orderClause = expr.Clauses[1] as QueryExpressionOrderClause;
 
342
                                
 
343
                                // From
 
344
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
345
                                
 
346
                                var var1 = fromClause.Sources.First();
 
347
                                
 
348
                                Assert.AreEqual("i", var1.Identifier);
 
349
                                Assert.IsTrue(var1.Expression is IdentifierExpression);
 
350
                                Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list");
 
351
                                
 
352
                                // Order By
 
353
                                Assert.AreEqual(1, orderClause.Orderings.Count);
 
354
                                
 
355
                                var ordering1 = orderClause.Orderings.First();
 
356
                                
 
357
                                Assert.IsTrue(ordering1.Criteria is IdentifierExpression &&
 
358
                                              (ordering1.Criteria as IdentifierExpression).Identifier == "i");
 
359
                                Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering1.Direction);
 
360
                        };
 
361
                        
 
362
                        RunTest(@"From i In list Order By i", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause));
 
363
                }
 
364
                
 
365
                [Test]
 
366
                public void OrderByTest2()
 
367
                {
 
368
                        Action<QueryExpression> constraint = expr => {
 
369
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
370
                                var orderClause = expr.Clauses[1] as QueryExpressionOrderClause;
 
371
                                
 
372
                                // From
 
373
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
374
                                
 
375
                                var var1 = fromClause.Sources.First();
 
376
                                
 
377
                                Assert.AreEqual("i", var1.Identifier);
 
378
                                Assert.IsTrue(var1.Expression is IdentifierExpression);
 
379
                                Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list");
 
380
                                
 
381
                                // Order By
 
382
                                Assert.AreEqual(1, orderClause.Orderings.Count);
 
383
                                
 
384
                                var ordering1 = orderClause.Orderings.First();
 
385
                                
 
386
                                Assert.IsTrue(ordering1.Criteria is IdentifierExpression &&
 
387
                                              (ordering1.Criteria as IdentifierExpression).Identifier == "i");
 
388
                                Assert.AreEqual(QueryExpressionOrderingDirection.Ascending, ordering1.Direction);
 
389
                        };
 
390
                        
 
391
                        RunTest(@"From i In list Order By i Ascending", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause));
 
392
                }
 
393
                
 
394
                [Test]
 
395
                public void OrderByTest3()
 
396
                {
 
397
                        Action<QueryExpression> constraint = expr => {
 
398
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
399
                                var orderClause = expr.Clauses[1] as QueryExpressionOrderClause;
 
400
                                
 
401
                                // From
 
402
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
403
                                
 
404
                                var var1 = fromClause.Sources.First();
 
405
                                
 
406
                                Assert.AreEqual("i", var1.Identifier);
 
407
                                Assert.IsTrue(var1.Expression is IdentifierExpression);
 
408
                                Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "list");
 
409
                                
 
410
                                // Order By
 
411
                                Assert.AreEqual(1, orderClause.Orderings.Count);
 
412
                                
 
413
                                var ordering1 = orderClause.Orderings.First();
 
414
                                
 
415
                                Assert.IsTrue(ordering1.Criteria is IdentifierExpression &&
 
416
                                              (ordering1.Criteria as IdentifierExpression).Identifier == "i");
 
417
                                Assert.AreEqual(QueryExpressionOrderingDirection.Descending, ordering1.Direction);
 
418
                        };
 
419
                        
 
420
                        RunTest(@"From i In list Order By i Descending", 2, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause));
 
421
                }
 
422
                
 
423
                [Test]
 
424
                public void OrderByThenByTest()
 
425
                {
 
426
                        Action<QueryExpression> constraint = expr => {
 
427
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
428
                                var orderClause = expr.Clauses[1] as QueryExpressionOrderClause;
 
429
                                
 
430
                                // From
 
431
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
432
                                
 
433
                                var var1 = fromClause.Sources.First();
 
434
                                
 
435
                                Assert.AreEqual("d", var1.Identifier);
 
436
                                Assert.IsTrue(var1.Expression is IdentifierExpression);
 
437
                                Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "digits");
 
438
                                
 
439
                                // Order By
 
440
                                Assert.AreEqual(2, orderClause.Orderings.Count);
 
441
                                
 
442
                                var ordering1 = orderClause.Orderings.First();
 
443
                                var ordering2 = orderClause.Orderings.Skip(1).First();
 
444
                                
 
445
                                CheckMemberReferenceExpression(ordering1.Criteria, "Length", "d");
 
446
 
 
447
                                Assert.IsTrue(ordering2.Criteria is IdentifierExpression &&
 
448
                                              (ordering2.Criteria as IdentifierExpression).Identifier == "d");
 
449
                                
 
450
                                Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering1.Direction);
 
451
                                Assert.AreEqual(QueryExpressionOrderingDirection.None, ordering2.Direction);
 
452
 
 
453
                        };
 
454
                        
 
455
                        RunTest(@"From d In digits _
 
456
        Order By d.Length, d", 2, constraint,
 
457
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionOrderClause));
 
458
                }
 
459
                
 
460
                [Test]
 
461
                public void DistinctTest()
 
462
                {
 
463
                        Action<QueryExpression> constraint = expr => {
 
464
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
465
                                
 
466
                                // From
 
467
                                Assert.AreEqual(1, fromClause.Sources.Count);
 
468
                                
 
469
                                var var1 = fromClause.Sources.First();
 
470
                                
 
471
                                Assert.AreEqual("d", var1.Identifier);
 
472
                                Assert.IsTrue(var1.Expression is IdentifierExpression);
 
473
                                Assert.IsTrue((var1.Expression as IdentifierExpression).Identifier == "digits");
 
474
                        };
 
475
                        
 
476
                        RunTest(@"From d In digits Distinct", 2, constraint,
 
477
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionDistinctClause));
 
478
                }
 
479
                
 
480
                [Test]
 
481
                public void AggregateTest()
 
482
                {
 
483
                        Action<QueryExpression> constraint = expr => {
 
484
                                var clause = expr.Clauses[0] as QueryExpressionAggregateClause;
 
485
                                
 
486
                                Assert.AreEqual("p", clause.Source.Identifier);
 
487
                                CheckMemberReferenceExpression(clause.Source.Expression, "GetProcesses", "Process");
 
488
                                
 
489
                                Assert.AreEqual(1, clause.IntoVariables.Count);
 
490
                                
 
491
                                var into1 = clause.IntoVariables.First();
 
492
                                
 
493
                                Assert.AreEqual("virtualMemory", into1.Identifier);
 
494
                                
 
495
                                Assert.IsTrue(into1.Expression is InvocationExpression &&
 
496
                                              (into1.Expression as InvocationExpression).TargetObject is IdentifierExpression &&
 
497
                                              ((into1.Expression as InvocationExpression).TargetObject as IdentifierExpression).Identifier == "Sum");
 
498
                                Assert.AreEqual(1, (into1.Expression as InvocationExpression).Arguments.Count);
 
499
                                CheckMemberReferenceExpression((into1.Expression as InvocationExpression).Arguments.First(), "VirtualMemorySize64", "p");
 
500
                        };
 
501
                        
 
502
                        RunTest(@"Aggregate p In Process.GetProcesses _
 
503
                        Into virtualMemory = Sum(p.VirtualMemorySize64)", 1, constraint, typeof(QueryExpressionAggregateClause));
 
504
                }
 
505
                
 
506
                [Test]
 
507
                public void GroupJoinTest()
 
508
                {
 
509
                        Action<QueryExpression> constraint = expr => {
 
510
                                var fromClause1 = expr.Clauses[0] as QueryExpressionFromClause;
 
511
                                var groupJoinClause = expr.Clauses[1] as QueryExpressionGroupJoinVBClause;
 
512
                                var fromClause2 = expr.Clauses[2] as QueryExpressionFromClause;
 
513
                                var selectClause = expr.Clauses[3] as QueryExpressionSelectVBClause;
 
514
                                
 
515
                                // From 1
 
516
                                Assert.AreEqual(1, fromClause1.Sources.Count);
 
517
                                
 
518
                                var var1 = fromClause1.Sources.First();
 
519
                                
 
520
                                Assert.AreEqual("s", var1.Identifier);
 
521
                                Assert.IsTrue(var1.Expression is IdentifierExpression &&
 
522
                                              (var1.Expression as IdentifierExpression).Identifier == "fileList");
 
523
                                
 
524
                                // From 2
 
525
                                Assert.AreEqual(1, fromClause2.Sources.Count);
 
526
                                
 
527
                                var var2 = fromClause2.Sources.First();
 
528
                                
 
529
                                Assert.AreEqual("p", var2.Identifier);
 
530
                                Assert.IsTrue(var2.Expression is IdentifierExpression &&
 
531
                                              (var2.Expression as IdentifierExpression).Identifier == "Group");
 
532
                                
 
533
                                // Select
 
534
                                Assert.AreEqual(1, selectClause.Variables.Count);
 
535
                                
 
536
                                var var3 = selectClause.Variables.First();
 
537
                                
 
538
                                Assert.IsEmpty(var3.Identifier);
 
539
                                Assert.IsTrue(var3.Expression is IdentifierExpression &&
 
540
                                              (var3.Expression as IdentifierExpression).Identifier == "s");
 
541
                                
 
542
                                // Group Join
 
543
                                var joinClause = groupJoinClause.JoinClause;
 
544
                                
 
545
                                // Join In On Equals
 
546
                                var inClause = joinClause.JoinVariable as CollectionRangeVariable;
 
547
                                
 
548
                                Assert.AreEqual("p", inClause.Identifier);
 
549
                                Assert.IsTrue(inClause.Expression is IdentifierExpression &&
 
550
                                              (inClause.Expression as IdentifierExpression).Identifier == "IMAGES");
 
551
                                
 
552
                                Assert.IsTrue(joinClause.SubJoin.IsNull);
 
553
                                
 
554
                                Assert.AreEqual(1, joinClause.Conditions.Count);
 
555
                                
 
556
                                var condition1 = joinClause.Conditions.First();
 
557
                                
 
558
                                Assert.IsTrue(condition1.LeftSide is InvocationExpression);
 
559
                                Assert.IsTrue((condition1.LeftSide as InvocationExpression).TargetObject is MemberReferenceExpression);
 
560
                                Assert.IsTrue(((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "ToUpper");
 
561
                                Assert.IsTrue(((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is MemberReferenceExpression);
 
562
                                Assert.IsTrue((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).MemberName == "Extension");
 
563
                                Assert.IsTrue((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression);
 
564
                                Assert.IsTrue(((((condition1.LeftSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "s");
 
565
                                
 
566
                                Assert.IsTrue(condition1.RightSide is InvocationExpression);
 
567
                                Assert.IsTrue((condition1.RightSide as InvocationExpression).TargetObject is MemberReferenceExpression);
 
568
                                Assert.IsTrue(((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).MemberName == "ToUpper");
 
569
                                Assert.IsTrue(((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject is IdentifierExpression);
 
570
                                Assert.IsTrue((((condition1.RightSide as InvocationExpression).TargetObject as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == "p");
 
571
                        };
 
572
                        
 
573
                        RunTest(@"From s In fileList _
 
574
Group Join p In IMAGES On s.Extension.ToUpper() Equals p.ToUpper() Into Group _
 
575
From p In Group _
 
576
Select s", 4, constraint,
 
577
                                typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupJoinVBClause), typeof(QueryExpressionFromClause), typeof(QueryExpressionSelectVBClause));
 
578
                }
 
579
                
 
580
                [Test]
 
581
                public void SelectManyTest()
 
582
                {
 
583
                        Action<QueryExpression> constraint = expr => {
 
584
                                var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 
585
                                var whereClause = expr.Clauses[1] as QueryExpressionWhereClause;
 
586
                                var selectClause = expr.Clauses[2] as QueryExpressionSelectVBClause;
 
587
                                
 
588
                                // From
 
589
                                Assert.AreEqual(2, fromClause.Sources.Count);
 
590
                                
 
591
                                var fromVar1 = fromClause.Sources.First();
 
592
                                var fromVar2 = fromClause.Sources.Skip(1).First();
 
593
                                
 
594
                                Assert.AreEqual("c", fromVar1.Identifier);
 
595
                                Assert.IsTrue(fromVar1.Expression is IdentifierExpression);
 
596
                                Assert.IsTrue((fromVar1.Expression as IdentifierExpression).Identifier == "customers");
 
597
                                
 
598
                                Assert.AreEqual("o", fromVar2.Identifier);
 
599
                                CheckMemberReferenceExpression(fromVar2.Expression, "Orders", "c");
 
600
                                
 
601
                                // Where
 
602
                                Assert.IsTrue(whereClause.Condition is BinaryOperatorExpression);
 
603
                                Assert.IsTrue((whereClause.Condition as BinaryOperatorExpression).Op == BinaryOperatorType.LessThan);
 
604
                                CheckMemberReferenceExpression((whereClause.Condition as BinaryOperatorExpression).Left, "Total", "o");
 
605
                                Assert.IsTrue((whereClause.Condition as BinaryOperatorExpression).Right is PrimitiveExpression);
 
606
                                Assert.IsTrue((double)((whereClause.Condition as BinaryOperatorExpression).Right as PrimitiveExpression).Value == 500.0);
 
607
                                
 
608
                                // Select
 
609
                                foreach (var v in selectClause.Variables) {
 
610
                                        Assert.IsEmpty(v.Identifier);
 
611
                                }
 
612
                                
 
613
                                var var1 = selectClause.Variables.First();
 
614
                                var var2 = selectClause.Variables.Skip(1).First();
 
615
                                var var3 = selectClause.Variables.Skip(2).First();
 
616
                                
 
617
                                CheckMemberReferenceExpression(var1.Expression, "CustomerID", "c");
 
618
                                CheckMemberReferenceExpression(var2.Expression, "OrderID", "o");
 
619
                                CheckMemberReferenceExpression(var3.Expression, "Total", "o");
 
620
                        };
 
621
                        
 
622
                        RunTest(@"From c In customers, o In c.Orders _
 
623
        Where o.Total < 500.0 _
 
624
        Select c.CustomerID, o.OrderID, o.Total", 3, constraint, typeof(QueryExpressionFromClause), typeof(QueryExpressionWhereClause), typeof(QueryExpressionSelectVBClause));
 
625
                }
 
626
                
 
627
                void CheckMemberReferenceExpression(Expression expr, string memberName, string targetObjectIdentifier)
 
628
                {
 
629
                        Assert.IsTrue(expr is MemberReferenceExpression);
 
630
                        Assert.IsTrue((expr as MemberReferenceExpression).MemberName == memberName &&
 
631
                                      (expr as MemberReferenceExpression).TargetObject is IdentifierExpression &&
 
632
                                      ((expr as MemberReferenceExpression).TargetObject as IdentifierExpression).Identifier == targetObjectIdentifier);
 
633
                }
 
634
        }
 
635
}