Tanoda
QueryTests.cs
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright (C) Ultraleap, Inc. 2011-2020. *
3 * *
4 * Use subject to the terms of the Apache License 2.0 available at *
5 * http://www.apache.org/licenses/LICENSE-2.0, or another agreement *
6 * between Ultraleap and you, your company or other organization. *
7 ******************************************************************************/
8
9using System.Linq;
10using System.Collections;
11using System.Collections.Generic;
12using UnityEngine;
13using NUnit.Framework;
14
15namespace Leap.Unity.Tests {
16 using Query;
17 using System;
18
19 public class QueryTests {
20
21 [Test]
22 public void AllTest([ValueSource("list0")] QueryArg arg) {
23 Assert.That(arg.ToQuery().All(i => i < 5), Is.EqualTo(
24 arg.ToList().All(i => i < 5)));
25
26 Assert.That(arg.ToQuery().All(i => i != 8), Is.EqualTo(
27 arg.ToList().All(i => i != 8)));
28 }
29
30 [Test]
31 public void AnyTest([ValueSource("list0")] QueryArg arg) {
32 Assert.That(arg.ToQuery().Any(i => i == 4), Is.EqualTo(
33 arg.ToList().Query().Any(i => i == 4)));
34 }
35
36 [Test]
37 public void Array2DTest() {
38 const int WIDTH = 23;
39 const int HEIGHT = 17;
40
41 int[,] array = new int[WIDTH, HEIGHT];
42 int counter = 0;
43 for (int i = 0; i < WIDTH; i++) {
44 for (int j = 0; j < HEIGHT; j++) {
45 array[i, j] = counter++;
46 }
47 }
48
49 Assert.That(array.Query().Count(), Is.EqualTo(WIDTH * HEIGHT));
50 foreach (var value in Enumerable.Range(0, WIDTH * HEIGHT)) {
51 Assert.That(array.Query().Contains(value));
52 }
53 }
54
55 [Test]
56 public void AverageTest([ValueSource("list0")] QueryArg arg0) {
57 if (arg0.ToList().Count == 0) {
58 Assert.Ignore("Ignore empty queries for average test.");
59 return;
60 }
61
62 Assert.That(arg0.ToQuery().Select(t => (double)t).Average(), Is.EqualTo(
63 arg0.ToList().Average()).Within(0.001).Percent);
64 }
65
66 [Test]
67 public void CastTest() {
68 object[] objs = new object[] { "Hello", "World", "These", "Are", "All", "Strings" };
69
70 Assert.That(objs.Cast<string>().SequenceEqual(
71 objs.Query().Cast<string>().ToList()));
72 }
73
74 [Test]
75 public void ConcatTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list0")] QueryArg arg1) {
76 Assert.That(arg0.ToQuery().Concat(arg1.ToList()).ToList(), Is.EquivalentTo(
77 arg0.ToList().Concat(arg1.ToList()).ToList()));
78
79 Assert.That(arg0.ToQuery().Concat(arg1.ToQuery()).ToList(), Is.EquivalentTo(
80 arg0.ToList().Concat(arg1.ToList()).ToList()));
81 }
82
83 [Test]
84 public void ContainsTest([ValueSource("list0")] QueryArg arg) {
85 Assert.That(arg.ToQuery().Contains(3), Is.EqualTo(
86 arg.ToList().Contains(3)));
87
88 Assert.That(arg.ToQuery().Contains(9), Is.EqualTo(
89 arg.ToList().Contains(9)));
90 }
91
92 [Test]
93 public void CountTests([ValueSource("list0")] QueryArg arg) {
94 Assert.That(arg.ToQuery().Count(), Is.EqualTo(
95 arg.ToList().Count()));
96
97 Assert.That(arg.ToQuery().Count(i => i % 2 == 0), Is.EqualTo(
98 arg.ToList().Count(i => i % 2 == 0)));
99 }
100
101 [Test]
102 public void DistinctTest([ValueSource("list0")] QueryArg arg) {
103 Assert.That(arg.ToQuery().Distinct().OrderBy(t => t).ToList(), Is.EquivalentTo(
104 arg.ToList().Distinct().OrderBy(t => t).ToList()));
105 }
106
107 [Test]
108 public void ElementAtTest([ValueSource("list0")] QueryArg arg, [Values(0, 3, 100)] int index) {
109 var list = arg.ToList();
110
111 if (index >= list.Count) {
112 Assert.That(() => arg.ToQuery().ElementAt(index), Throws.InstanceOf<IndexOutOfRangeException>());
113 } else {
114 Assert.That(arg.ToQuery().ElementAt(index), Is.EqualTo(
115 arg.ToList().ElementAt(index)));
116 }
117 }
118
119 [Test]
120 public void EnumeratorTest() {
121 Assert.AreEqual(new TestEnumerator().Query().IndexOf(3), 3);
122 }
123
124 [Test]
125 public void FirstTests([ValueSource("list0")] QueryArg arg) {
126 var list = arg.ToList();
127
128 if (list.Count == 0) {
129 Assert.That(() => arg.ToQuery().First(), Throws.InvalidOperationException);
130 } else {
131 Assert.That(arg.ToQuery().First(), Is.EqualTo(
132 arg.ToList().First()));
133 }
134
135 if (list.Where(i => i % 2 == 0).Count() == 0) {
136 Assert.That(() => arg.ToQuery().Where(i => i % 2 == 0).First(), Throws.InvalidOperationException);
137 } else {
138 Assert.That(arg.ToQuery().First(i => i % 2 == 0), Is.EqualTo(
139 arg.ToList().First(i => i % 2 == 0)));
140 }
141 }
142
143 [Test]
144 public void FirstOrDefaultTests([ValueSource("list0")] QueryArg arg) {
145 Assert.That(arg.ToQuery().FirstOrDefault(), Is.EqualTo(
146 arg.ToList().FirstOrDefault()));
147
148 Assert.That(arg.ToQuery().FirstOrDefault(i => i % 2 == 0), Is.EqualTo(
149 arg.ToList().FirstOrDefault(i => i % 2 == 0)));
150
151 Assert.That(arg.ToQuery().FirstOrDefault(i => i > 10), Is.EqualTo(
152 arg.ToList().FirstOrDefault(i => i > 10)));
153 }
154
155 [Test]
156 public void FoldTest([ValueSource("list0")] QueryArg arg) {
157 var list = arg.ToList();
158
159 if (list.Count == 0) {
160 Assert.That(() => arg.ToQuery().Fold((a, b) => a + b), Throws.InvalidOperationException);
161 } else {
162 Assert.That(arg.ToQuery().Fold((a, b) => a + b), Is.EqualTo(
163 arg.ToList().Sum()));
164 }
165 }
166
167 [Test]
168 public void ForeachTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list1")] QueryArg arg1) {
169 List<int> actual = new List<int>();
170 foreach (var item in arg0.ToQuery().Concat(arg1.ToQuery())) {
171 actual.Add(item);
172 }
173 Assert.That(actual, Is.EquivalentTo(
174 arg0.ToList().Concat(arg1.ToList()).ToList()));
175 }
176
177 [Test]
178 public void IndexOfTests([ValueSource("list0")] QueryArg arg) {
179 Assert.That(arg.ToQuery().IndexOf(3), Is.EqualTo(
180 arg.ToList().IndexOf(3)));
181
182 Assert.That(arg.ToQuery().IndexOf(100), Is.EqualTo(
183 arg.ToList().IndexOf(100)));
184 }
185
186 [Test]
187 public void LastTests([ValueSource("list0")] QueryArg arg) {
188 var list = arg.ToList();
189
190 if (list.Count == 0) {
191 Assert.That(() => arg.ToQuery().Last(), Throws.InvalidOperationException);
192 } else {
193 Assert.That(arg.ToQuery().Last(), Is.EqualTo(
194 arg.ToList().Last()));
195 }
196
197 Assert.That(arg.ToQuery().LastOrDefault(), Is.EqualTo(
198 arg.ToList().LastOrDefault()));
199 }
200
201 [Test]
202 public void MaxTest([ValueSource("list0")] QueryArg arg) {
203 if (arg.ToList().Count == 0) {
204 Assert.Ignore("Ignore empty queries for max tests.");
205 return;
206 }
207
208 Assert.That(arg.ToQuery().Max(), Is.EqualTo(
209 arg.ToList().Max()));
210 }
211
212 [Test]
213 public void MinTest([ValueSource("list0")] QueryArg arg) {
214 if (arg.ToList().Count == 0) {
215 Assert.Ignore("Ignore empty queries for min tests.");
216 return;
217 }
218
219 Assert.That(arg.ToQuery().Min(), Is.EqualTo(
220 arg.ToList().Min()));
221 }
222
223 [Test]
224 public void MultiFirstTest([ValueSource("list0")] QueryArg arg) {
225 var q = arg.ToQuery();
226
227 q.FirstOrDefault();
228
229 Assert.That(() => q.FirstOrDefault(), Throws.InvalidOperationException);
230 }
231
232 [Test]
233 public void MultiForeachTest([ValueSource("list0")] QueryArg arg) {
234 List<int> a = new List<int>();
235 List<int> b = new List<int>();
236
237 var q = arg.ToQuery();
238 foreach (var item in q) {
239 a.Add(item);
240 }
241
242 Assert.That(() => {
243 foreach (var item in q) {
244 b.Add(item);
245 }
246 }, Throws.InvalidOperationException);
247 }
248
249 [Test]
250 public void OfTypeTest() {
251 object[] objs = new object[] { 0, 0.4f, "Hello", 7u, 0.4, "World", null };
252
253 Assert.That(objs.OfType<string>().ToList(), Is.EquivalentTo(
254 objs.Query().OfType<string>().ToList()));
255
256 Assert.That(objs.OfType<string>(), Is.EquivalentTo(
257 objs.Query().OfType(typeof(string)).Cast<string>().ToList()));
258 }
259
260 [Test]
261 public void OrderByTest([ValueSource("list0")] QueryArg arg) {
262 Assert.That(arg.ToQuery().OrderBy(i => i).ToList(), Is.EquivalentTo(
263 arg.ToList().OrderBy(i => i).ToList()));
264 }
265
266 [Test]
267 public void OrderByDescendingTest([ValueSource("list0")] QueryArg arg) {
268 Assert.That(arg.ToQuery().OrderByDescending(i => i).ToList(), Is.EquivalentTo(
269 arg.ToList().OrderByDescending(i => i).ToList()));
270 }
271
272 [Test]
273 [Pairwise]
274 public void RangeFromTo([Values(0, 1, 100, -1, -100)] int startValue,
275 [Values(0, 1, 100, -1, -100)] int endValue,
276 [Values(1, 2, 10)] int step,
277 [Values(true, false)] bool endIsExclusive) {
278 List<int> expected = new List<int>();
279 int value = startValue;
280 int signStep = endValue > startValue ? step : -step;
281 for (int i = 0; i < Mathf.Abs(startValue - endValue) + 1; i++) {
282 expected.Add(value);
283 value += signStep;
284 }
285
286 if (endIsExclusive) {
287 expected.Remove(endValue);
288 }
289
290 expected = expected.Where(i => i >= Mathf.Min(startValue, endValue)).
291 Where(i => i <= Mathf.Max(startValue, endValue)).
292 ToList();
293
294 Assert.That(Values.Range(startValue, endValue, step, endIsExclusive).ToList(), Is.EquivalentTo(expected));
295 }
296
297 [Test]
298 public void Repeat([ValueSource("list0")] QueryArg arg, [Values(0, 1, 2, 3, 100)] int repetitions) {
299 List<int> list = new List<int>();
300 for (int i = 0; i < repetitions; i++) {
301 list.AddRange(arg.ToList());
302 }
303
304 Assert.That(arg.ToQuery().Repeat(repetitions).ToList(), Is.EquivalentTo(
305 list));
306 }
307
308 [Test]
309 public void ReverseTest([ValueSource("list0")] QueryArg arg) {
310 var expected = arg.ToList();
311 expected.Reverse();
312
313 Assert.That(arg.ToQuery().Reverse().ToList(), Is.EquivalentTo(
314 expected));
315 }
316
317 [Test]
318 public void SelectTest([ValueSource("list0")] QueryArg arg) {
319 Assert.That(arg.ToQuery().Select(i => i * 23).ToList(), Is.EquivalentTo(
320 arg.ToList().Select(i => i * 23).ToList()));
321 }
322
323 [Test]
324 public void SelectManyTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list0")] QueryArg arg1) {
325 Assert.That(arg0.ToQuery().SelectMany(i => arg1.ToQuery().Select(j => j * i)).ToList(), Is.EquivalentTo(
326 arg0.ToList().SelectMany(i => arg1.ToList().Select(j => j * i)).ToList()));
327
328 Assert.That(arg0.ToQuery().SelectMany(i => arg1.ToList().Select(j => j * i).ToList()).ToList(), Is.EquivalentTo(
329 arg0.ToList().SelectMany(i => arg1.ToList().Select(j => j * i)).ToList()));
330 }
331
332 [Test]
333 public void SelectManyEmptyTest() {
334 new int[] { }.Query().SelectMany(i => new int[] { }.Query()).ToList();
335 }
336
337 [Test]
338 public void SingleTest() {
339 var array = new int[] { 5 };
340 Assert.That(array.Single(), Is.EqualTo(array.Query().Single()));
341
342 Assert.That(() => {
343 new int[] { }.Query().Single();
344 }, Throws.InvalidOperationException);
345
346 Assert.That(() => {
347 new int[] { 0, 1 }.Query().Single();
348 }, Throws.InvalidOperationException);
349 }
350
351 [Test]
352 public void SkipTest([ValueSource("list0")] QueryArg arg) {
353 Assert.That(arg.ToQuery().Skip(3).ToList(), Is.EquivalentTo(
354 arg.ToList().Skip(3).ToList()));
355 }
356
357 [Test]
358 public void SkipWhileTest([ValueSource("list0")] QueryArg arg) {
359 Assert.That(arg.ToQuery().SkipWhile(i => i < 4).ToList(), Is.EquivalentTo(
360 arg.ToList().SkipWhile(i => i < 4).ToList()));
361 }
362
363 [Test]
364 public void SortTest([ValueSource("list0")] QueryArg arg) {
365 var expected = arg.ToList();
366 expected.Sort();
367
368 Assert.That(arg.ToQuery().Sort().ToList(), Is.EquivalentTo(
369 expected));
370 }
371
372 [Test]
373 public void SortDescendingTests([ValueSource("list0")] QueryArg arg) {
374 var expected = arg.ToList();
375 expected.Sort();
376 expected.Reverse();
377
378 Assert.That(arg.ToQuery().SortDescending().ToList(), Is.EquivalentTo(
379 expected));
380 }
381
382 [Test]
383 public void SumTests([ValueSource("list0")] QueryArg arg) {
384 if (arg.ToList().Count == 0) {
385 Assert.Ignore("Ignore empty queries for sum tests.");
386 return;
387 }
388
389 Assert.That(arg.ToQuery().Sum(), Is.EqualTo(
390 arg.ToList().Sum()));
391 }
392
393 [Test]
394 public void TakeTest([ValueSource("list0")] QueryArg arg) {
395 Assert.That(arg.ToQuery().Take(4).ToList(), Is.EquivalentTo(
396 arg.ToList().Take(4).ToList()));
397 }
398
399 [Test]
400 public void TakeWhileTest([ValueSource("list0")] QueryArg arg) {
401 Assert.That(arg.ToQuery().TakeWhile(i => i < 4).ToList(), Is.EquivalentTo(
402 arg.ToList().TakeWhile(i => i < 4).ToList()));
403 }
404
405 [Test]
406 public void WithPreviousTest([ValueSource("list0")] QueryArg arg) {
407 var list = arg.ToList();
408 if (list.Count == 0) {
409 Assert.That(arg.ToQuery().WithPrevious().Count(), Is.EqualTo(0));
410 Assert.That(arg.ToQuery().WithPrevious(includeStart: true).Count(), Is.EqualTo(0));
411 } else if (list.Count == 1) {
412 Assert.That(arg.ToQuery().WithPrevious().Count(), Is.EqualTo(0));
413 Assert.That(arg.ToQuery().WithPrevious(includeStart: true).Count(), Is.EqualTo(1));
414 } else {
415 Assert.That(arg.ToQuery().WithPrevious().Count(p => p.hasPrev), Is.EqualTo(list.Count - 1));
416 Assert.That(arg.ToQuery().WithPrevious(includeStart: true).Count(p => !p.hasPrev), Is.EqualTo(1));
417 Assert.That(arg.ToQuery().WithPrevious(includeStart: true).Count(p => p.hasPrev), Is.EqualTo(list.Count - 1));
418 }
419
420 int index = 0;
421 foreach (var pair in arg.ToQuery().WithPrevious()) {
422 Assert.That(pair.prev, Is.EqualTo(list[index]));
423 index++;
424 }
425 }
426
427 [Test]
428 public void WithPreviousOffsetTest([ValueSource("list0")] QueryArg arg) {
429 var list = arg.ToList();
430 if (list.Count == 0) {
431 Assert.That(arg.ToQuery().WithPrevious(offset: 4).Count(), Is.EqualTo(0));
432 Assert.That(arg.ToQuery().WithPrevious(offset: 4, includeStart: true).Count(), Is.EqualTo(0));
433 } else if (list.Count == 1) {
434 Assert.That(arg.ToQuery().WithPrevious(offset: 4).Count(), Is.EqualTo(0));
435 Assert.That(arg.ToQuery().WithPrevious(offset: 4, includeStart: true).Count(), Is.EqualTo(1));
436 } else {
437 Assert.That(arg.ToQuery().WithPrevious(offset: 4).Count(), Is.EqualTo(Mathf.Max(0, list.Count - 4)));
438 Assert.That(arg.ToQuery().WithPrevious(offset: list.Count + 1).Count(), Is.EqualTo(0));
439 Assert.That(arg.ToQuery().WithPrevious(offset: int.MaxValue).Count(), Is.EqualTo(0));
440 }
441
442 Assert.That(Values.Range(0, 10).WithPrevious(offset: 2).All(i => i.value - i.prev == 2));
443 }
444
445 [Test]
446 public void WhereTest([ValueSource("list0")] QueryArg arg) {
447 Assert.That(arg.ToQuery().Where(i => i % 2 == 0).ToList(), Is.EquivalentTo(
448 arg.ToList().Where(i => i % 2 == 0).ToList()));
449 }
450
451 [Test]
452 public void WithIndicesTest([ValueSource("list0")] QueryArg arg) {
453 int index = 0;
454 foreach (var item in arg.ToQuery().WithIndices()) {
455 Assert.That(item.index, Is.EqualTo(index));
456 Assert.That(item.value, Is.EqualTo(arg.ToList()[index]));
457 index++;
458 }
459 }
460
461 [Test]
462 public void ZipTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list1")] QueryArg arg1) {
463 var list0 = arg0.ToList();
464 var list1 = arg1.ToList();
465
466 List<string> expected = new List<string>();
467 for (int i = 0; i < Mathf.Min(list0.Count, list1.Count); i++) {
468 expected.Add(list0[i].ToString() + list1[i].ToString());
469 }
470
471 Assert.That(arg0.ToQuery().Zip(arg1.ToQuery(), (a, b) => a.ToString() + b.ToString()).ToList(), Is.EquivalentTo(
472 expected));
473
474 Assert.That(arg0.ToQuery().Zip(arg1.ToList(), (a, b) => a.ToString() + b.ToString()).ToList(), Is.EquivalentTo(
475 expected));
476 }
477
478 private static IEnumerable<QueryArg> list0 {
479 get {
480 List<int> values = new List<int>() { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 9, 1, 900, int.MinValue, int.MaxValue };
481 List<int> lengths = new List<int>() {
482 0,
483 1,
484 2,
485 int.MaxValue
486 };
487
488 foreach (var length in lengths) {
489 var list = values.Take(length).ToList();
490 yield return new QueryArg(list, list.Count);
491 yield return new QueryArg(list, list.Count * 10 + 10);
492 }
493 }
494 }
495
496 private static IEnumerable<QueryArg> list1 {
497 get {
498 List<int> values = new List<int>() { 6, 7, 8, 9, 10, 1, 1, 9, 300, 6, 900, int.MaxValue };
499 List<int> lengths = new List<int>() {
500 0,
501 1,
502 2,
503 int.MaxValue
504 };
505
506 foreach (var length in lengths) {
507 var list = values.Take(length).ToList();
508 yield return new QueryArg(list, list.Count);
509 yield return new QueryArg(list, list.Count * 10 + 10);
510 }
511 }
512 }
513
514 public class QueryArg {
515 private int[] _array;
516 private int _count;
517
518 public QueryArg(List<int> values, int capacity) {
519 _array = new int[capacity];
520 values.CopyTo(_array);
521 _count = values.Count;
522 }
523
525 int[] copy = new int[_array.Length];
526 _array.CopyTo(copy, 0);
527 return new Query<int>(copy, _count);
528 }
529
530 public List<int> ToList() {
531 return new List<int>(_array.Take(_count));
532 }
533
534 public override string ToString() {
535 return _array.Length + " : " + Utils.ToArrayString(_array.Take(_count));
536 }
537 }
538
539
540 public class TestEnumerator : IEnumerator<int> {
541 private int _curr = -1;
542
543 public int Current {
544 get {
545 return _curr;
546 }
547 }
548
549 public bool MoveNext() {
550 _curr++;
551 return (_curr != 10);
552 }
553
554 object IEnumerator.Current { get { return null; } }
555 public void Dispose() { }
556 public void Reset() { }
557 }
558 }
559}
QueryArg(List< int > values, int capacity)
Definition: QueryTests.cs:518
void FirstTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:125
void SkipWhileTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:358
void AllTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:22
void MultiFirstTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:224
void FirstOrDefaultTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:144
void OrderByDescendingTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:267
void SortDescendingTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:373
void ContainsTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:84
void ZipTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list1")] QueryArg arg1)
Definition: QueryTests.cs:462
void MinTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:213
void ForeachTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list1")] QueryArg arg1)
Definition: QueryTests.cs:168
void WithPreviousTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:406
void IndexOfTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:178
void WithIndicesTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:452
void OrderByTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:261
void DistinctTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:102
void AverageTest([ValueSource("list0")] QueryArg arg0)
Definition: QueryTests.cs:56
void ReverseTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:309
void WithPreviousOffsetTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:428
void SkipTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:352
void TakeWhileTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:400
void MultiForeachTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:233
void WhereTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:446
void LastTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:187
void FoldTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:156
void SortTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:364
void ConcatTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list0")] QueryArg arg1)
Definition: QueryTests.cs:75
void AnyTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:31
void SelectManyTest([ValueSource("list0")] QueryArg arg0, [ValueSource("list0")] QueryArg arg1)
Definition: QueryTests.cs:324
void SumTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:383
void SelectTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:318
void ElementAtTest([ValueSource("list0")] QueryArg arg, [Values(0, 3, 100)] int index)
Definition: QueryTests.cs:108
void Repeat([ValueSource("list0")] QueryArg arg, [Values(0, 1, 2, 3, 100)] int repetitions)
Definition: QueryTests.cs:298
void RangeFromTo([Values(0, 1, 100, -1, -100)] int startValue, [Values(0, 1, 100, -1, -100)] int endValue, [Values(1, 2, 10)] int step, [Values(true, false)] bool endIsExclusive)
Definition: QueryTests.cs:274
void CountTests([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:93
void MaxTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:202
void TakeTest([ValueSource("list0")] QueryArg arg)
Definition: QueryTests.cs:394
A Query object is a type of immutable ordered collection of elements that can be used to perform usef...
Definition: Query.cs:90