?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2010-04-15 Jérémie Laval <jeremie.laval@gmail.com>
[mcs.git] / class / System.Core / Test / System.Linq / ParallelEnumerableTests.cs
blob886020b23fbd503906075caf80e4543a8934c729
1 // ParallelEnumerableTests.cs
2 //
3 // Copyright (c) 2008 Jérémie "Garuma" Laval
4 //
5 // Based on Enumerable test suite by Jb Evain (jbevain@novell.com)
6 //
7 // Permission is hereby granted, free of charge, to any person obtaining a copy
8 // of this software and associated documentation files (the "Software"), to deal
9 // in the Software without restriction, including without limitation the rights
10 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 // copies of the Software, and to permit persons to whom the Software is
12 // furnished to do so, subject to the following conditions:
13 //
14 // The above copyright notice and this permission notice shall be included in
15 // all copies or substantial portions of the Software.
16 //
17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 // THE SOFTWARE.
24 //
25 //
26
27 using System;
28 using System.Threading;
29 using System.Linq;
30
31 using System.Collections;
32 using System.Collections.Generic;
33
34 using NUnit.Framework;
35
36 namespace MonoTests.System.Linq.Parallel
37 {
38 [TestFixtureAttribute]
39 public class ParallelEnumerableTests
40 {
41 IEnumerable<int> baseEnumerable;
42
43 [SetUpAttribute]
44 public void Setup ()
45 {
46 baseEnumerable = Enumerable.Range(1, 10000);
47 }
48
49 void AreEquivalent (IEnumerable<int> syncEnumerable, IEnumerable<int> asyncEnumerable, int count)
50 {
51 int[] sync = Enumerable.ToArray(syncEnumerable);
52 int[] async = Enumerable.ToArray(asyncEnumerable);
53
54 // This is not AreEquals because ParallelQuery is non-deterministic (IParallelOrderedEnumerable is)
55 // thus the order of the initial Enumerable might not be preserved
56 CollectionAssert.AreEquivalent(sync, async, "#" + count);
57 }
58
59 void AreEquivalent<T> (IEnumerable<T> syncEnumerable, IEnumerable<T> asyncEnumerable, int count)
60 {
61 T[] sync = Enumerable.ToArray(syncEnumerable);
62 T[] async = Enumerable.ToArray(asyncEnumerable);
63
64 // This is not AreEquals because ParallelQuery is non-deterministic (IParallelOrderedEnumerable is)
65 // thus the order of the initial Enumerable might not be preserved
66 CollectionAssert.AreEquivalent(sync, async, "#" + count);
67 }
68
69 static void AssertAreSame<T> (IEnumerable<T> expected, IEnumerable<T> actual)
70 {
71 if (expected == null) {
72 Assert.IsNull (actual);
73 return;
74 }
75
76 Assert.IsNotNull (actual);
77
78 IEnumerator<T> ee = expected.GetEnumerator ();
79 IEnumerator<T> ea = actual.GetEnumerator ();
80
81 while (ee.MoveNext ()) {
82 Assert.IsTrue (ea.MoveNext (), "'" + ee.Current + "' expected.");
83 Assert.AreEqual (ee.Current, ea.Current);
84 }
85
86 if (ea.MoveNext ())
87 Assert.Fail ("Unexpected element: " + ea.Current);
88 }
89
90 public static void AssertException<T> (Action action) where T : Exception
91 {
92 try {
93 action ();
94 }
95 catch (T) {
96 return;
97 }
98 Assert.Fail ("Expected: " + typeof (T).Name);
99 }
100
101 static void AssertAreSame<K, V> (K expectedKey, IEnumerable<V> expectedValues, IGrouping<K, V> actual)
102 {
103 if (expectedValues == null) {
104 Assert.IsNull (actual);
105 return;
106 }
107
108 Assert.IsNotNull (actual);
109
110 Assert.AreEqual (expectedKey, actual.Key);
111
112 var ee = expectedValues.GetEnumerator ();
113 var ea = actual.GetEnumerator ();
114
115 while (ee.MoveNext ()) {
116 Assert.IsTrue (ea.MoveNext (), "'" + ee.Current + "' expected.");
117 Assert.AreEqual (ee.Current, ea.Current);
118 }
119
120 if (ea.MoveNext ())
121 Assert.Fail ("Unexpected element: " + ee.Current);
122 }
123
124 static void AssertAreSame<K, V> (IDictionary<K, IEnumerable<V>> expected, IEnumerable<IGrouping<K, V>> actual)
125 {
126 if (expected == null) {
127 Assert.IsNull (actual);
128 return;
129 }
130
131 Assert.IsNotNull (actual);
132
133 var ee = expected.GetEnumerator ();
134 var ea = actual.GetEnumerator ();
135
136 while (ee.MoveNext ()) {
137 Assert.IsTrue (ea.MoveNext (), "'" + ee.Current.Key + "' expected.");
138 AssertAreSame (ee.Current.Key, ee.Current.Value, ea.Current);
139 }
140
141 if (ea.MoveNext ())
142 Assert.Fail ("Unexpected element: " + ee.Current.Key);
143 }
144
145 static void AssertAreSame<K, V> (IDictionary<K, IEnumerable<V>> expected, ILookup<K, V> actual)
146 {
147 if (expected == null) {
148 Assert.IsNull (actual);
149 return;
150 }
151
152 Assert.IsNotNull (actual);
153
154 var ee = expected.GetEnumerator ();
155 var ea = actual.GetEnumerator ();
156
157 while (ee.MoveNext ()) {
158 Assert.IsTrue (ea.MoveNext (), "'" + ee.Current.Key + "' expected.");
159 AssertAreSame (ee.Current.Key, ee.Current.Value, ea.Current);
160 }
161
162 if (ea.MoveNext ())
163 Assert.Fail ("Unexpected element: " + ee.Current.Key);
164 }
165
166 static void AssertAreSame<K, V> (IDictionary<K, V> expected, IDictionary<K, V> actual)
167 {
168 if (expected == null) {
169 Assert.IsNull (actual);
170 return;
171 }
172
173 Assert.IsNotNull (actual);
174
175 var ee = expected.GetEnumerator ();
176 var ea = actual.GetEnumerator ();
177
178 while (ee.MoveNext ()) {
179 Assert.IsTrue (ea.MoveNext (), "'" + ee.Current.Key + ", " + ee.Current.Value + "' expected.");
180 Assert.AreEqual (ee.Current.Key, ea.Current.Key);
181 Assert.AreEqual (ee.Current.Value, ea.Current.Value);
182 }
183
184 if (ea.MoveNext ())
185 Assert.Fail ("Unexpected element: " + ee.Current.Key + ", " + ee.Current.Value);
186 }
187
188 [Test]
189 public void SelectTestCase ()
190 {
191 ParallelTestHelper.Repeat (() => {
192 IEnumerable<int> sync = baseEnumerable.Select (i => i * i);
193 IEnumerable<int> async = baseEnumerable.AsParallel ().Select (i => i * i);
194
195 AreEquivalent(sync, async, 1);
196 });
197 }
198
199 [Test]
200 public void WhereTestCase ()
201 {
202 ParallelTestHelper.Repeat (() => {
203 IEnumerable<int> sync = baseEnumerable.Where(i => i % 2 == 0);
204 IEnumerable<int> async = baseEnumerable.AsParallel().Where(i => i % 2 == 0);
205
206 AreEquivalent(sync, async, 1);
207 });
208 }
209
210 [Test]
211 public void CountTestCase ()
212 {
213 ParallelTestHelper.Repeat (() => {
214 int sync = baseEnumerable.Count();
215 int async = baseEnumerable.AsParallel().Count();
216
217 Assert.AreEqual(sync, async, "#1");
218 });
219 }
220
221 [Test]
222 public void AggregateTestCase ()
223 {
224 ParallelTestHelper.Repeat (() => {
225 ParallelQuery<int> range = ParallelEnumerable.Repeat (5, 2643);
226 double average = range.Aggregate(() => new double[2],
227 (acc, elem) => { acc[0] += elem; acc[1]++; return acc; },
228 (acc1, acc2) => { acc1[0] += acc2[0]; acc1[1] += acc2[1]; return acc1; },
229 acc => acc[0] / acc[1]);
230
231 Assert.AreEqual(5.0, average, "#1");
232 });
233 }
234
235 [Test]
236 public void TestSimpleExcept ()
237 {
238 ParallelTestHelper.Repeat (() => {
239 int [] first = {0, 1, 2, 3, 4, 5};
240 int [] second = {2, 4, 6};
241 int [] result = {0, 1, 3, 5};
242
243 AreEquivalent (result, first.AsParallel ().Except (second.AsParallel ()), 1);
244 });
245 }
246
247 [Test]
248 public void TestSimpleIntersect ()
249 {
250 ParallelTestHelper.Repeat (() => {
251 int [] first = {0, 1, 2, 3, 4, 5};
252 int [] second = {2, 4, 6};
253 int [] result = {2, 4};
254
255 AreEquivalent (result, first.AsParallel ().Intersect (second.AsParallel ()), 1);
256 });
257 }
258
259 [Test]
260 public void TestSimpleUnion ()
261 {
262 ParallelTestHelper.Repeat (() => {
263 int [] first = {0, 1, 2, 3, 4, 5};
264 int [] second = {2, 4, 6};
265 int [] result = {0, 1, 2, 3, 4, 5, 6};
266
267 AreEquivalent (result, first.AsParallel ().Union (second.AsParallel ()), 1);
268 });
269 }
270
271 class Foo {}
272 class Bar : Foo {}
273
274 [Test]
275 public void TestCast ()
276 {
277 Bar a = new Bar ();
278 Bar b = new Bar ();
279 Bar c = new Bar ();
280
281 Foo [] foos = new Foo [] {a, b, c};
282 Bar [] result = new Bar [] {a, b, c};
283
284 AreEquivalent (result, foos.AsParallel ().Cast<Bar> (), 1);
285 }
286
287 [Test]
288 public void TestSkip ()
289 {
290 int [] data = {0, 1, 2, 3, 4, 5};
291 int [] result = {3, 4, 5};
292
293 AssertAreSame (result, data.AsParallel ().AsOrdered ().Skip (3));
294 }
295
296 /*[Test]
297 public void TestSkipWhile ()
298 {
299 int [] data = {0, 1, 2, 3, 4, 5};
300 int [] result = {3, 4, 5};
301
302 AssertAreSame (result, data.AsParallel ().AsOrdered ().SkipWhile (i => i < 3));
303 }
304
305 [Test]
306 public void TestTake ()
307 {
308 int [] data = {0, 1, 2, 3, 4, 5};
309 int [] result = {0, 1, 2};
310
311 AssertAreSame (result, data.AsParallel ().AsOrdered ().Take (3));
312 }
313
314 [Test]
315 public void TestTakeWhile ()
316 {
317 int [] data = {0, 1, 2, 3, 4, 5};
318 int [] result = {0, 1, 2};
319
320 AssertAreSame (result, data.AsParallel ().AsOrdered ().TakeWhile (i => i < 3));
321 }*/
322
323 // [Test]
324 // public void TestLast ()
325 // {
326 // int [] data = {1, 2, 3};
327 //
328 // Assert.AreEqual (3, data.AsParallel ().Last ());
329 // }
330 //
331 // [Test]
332 // public void TestLastOrDefault ()
333 // {
334 // int [] data = {};
335 //
336 // Assert.AreEqual (default (int), data.AsParallel ().LastOrDefault ());
337 // }
338 //
339 // [Test]
340 // public void TestFirst ()
341 // {
342 // int [] data = {1, 2, 3};
343 //
344 // Assert.AreEqual (1, data.AsParallel ().First ());
345 // }
346 //
347 // [Test]
348 // public void TestFirstOrDefault ()
349 // {
350 // int [] data = {};
351 //
352 // Assert.AreEqual (default (int), data.AsParallel ().FirstOrDefault ());
353 // }
354
355 [Test]
356 public void TestReverse ()
357 {
358 int [] data = {0, 1, 2, 3, 4};
359 int [] result = {4, 3, 2, 1, 0};
360
361 AssertAreSame (result, data.AsParallel ().AsOrdered ().Reverse ());
362 AssertAreSame (result, ParallelEnumerable.Range (0, 5).AsOrdered ().Reverse ());
363 }
364
365 [Test]
366 public void TestOrderBy ()
367 {
368 ParallelTestHelper.Repeat (() => {
369 int [] array = { 14, 53, 3, 9, 11, 14, 5, 32, 2 };
370
371 var q = array.AsParallel ().OrderBy ((i) => i);
372 AssertIsOrdered (q, array.Length);
373 });
374 }
375
376 class Baz {
377 string name;
378 int age;
379
380 public string Name
381 {
382 get {
383 if (string.IsNullOrEmpty (name))
384 return Age.ToString ();
385
386 return name + " (" + Age + ")";
387 }
388 }
389
390 public int Age
391 {
392 get { return age + 1; }
393 }
394
395 public Baz (string name, int age)
396 {
397 this.name = name;
398 this.age = age;
399 }
400
401 public override int GetHashCode ()
402 {
403 return this.Age ^ this.Name.GetHashCode ();
404 }
405
406 public override bool Equals (object obj)
407 {
408 Baz b = obj as Baz;
409 if (b == null)
410 return false;
411
412 return b.Age == this.Age && b.Name == this.Name;
413 }
414
415 public override string ToString ()
416 {
417 return this.Name;
418 }
419 }
420
421 static IEnumerable<Baz> CreateBazCollection ()
422 {
423 return new [] {
424 new Baz ("jb", 25),
425 new Baz ("ana", 20),
426 new Baz ("reg", 28),
427 new Baz ("ro", 25),
428 new Baz ("jb", 7),
429 };
430 }
431
432 [Test]
433 public void TestOrderByAgeAscendingTheByNameDescending ()
434 {
435 ParallelTestHelper.Repeat (() => {
436 var q = from b in CreateBazCollection ().AsParallel()
437 orderby b.Age ascending, b.Name descending
438 select b;
439 //var q = CreateBazCollection ().AsParallel ().OrderBy ((b) => b.Age).ThenByDescending ((b) => b.Name);
440
441 var expected = new [] {
442 new Baz ("jb", 7),
443 new Baz ("ana", 20),
444 new Baz ("ro", 25),
445 new Baz ("jb", 25),
446 new Baz ("reg", 28),
447 };
448
449 foreach (Baz b in q) {
450 Console.Write(b.Name + ", " + b.Age + "; ");
451 }
452
453 AssertAreSame (expected, q);
454 });
455 }
456
457 class Data {
458 public int ID { get; set; }
459 public string Name { get; set; }
460
461 public override string ToString ()
462 {
463 return ID + " " + Name;
464 }
465 }
466
467 IEnumerable<Data> CreateData ()
468 {
469 return new [] {
470 new Data { ID = 10, Name = "bcd" },
471 new Data { ID = 20, Name = "Abcd" },
472 new Data { ID = 20, Name = "Ab" },
473 new Data { ID = 10, Name = "Zyx" },
474 };
475 }
476
477 [Test]
478 public void TestOrderByIdDescendingThenByNameAscending ()
479 {
480 ParallelTestHelper.Repeat (() => {
481 var q = from d in CreateData ().AsParallel()
482 orderby d.ID descending, d.Name ascending
483 select d;
484
485 var list = new List<Data> (q);
486
487 Assert.AreEqual ("Ab", list [0].Name);
488 Assert.AreEqual ("Abcd", list [1].Name);
489 Assert.AreEqual ("bcd", list [2].Name);
490 Assert.AreEqual ("Zyx", list [3].Name);
491 });
492 }
493
494 static void AssertIsOrdered (IEnumerable<int> e, int count)
495 {
496 int f = int.MinValue;
497 int c = 0;
498
499 foreach (int i in e) {
500 Assert.IsTrue (f <= i, string.Format ("{0} <= {1}", f, i));
501 f = i;
502 c++;
503 }
504
505 Assert.AreEqual (count, c);
506 }
507
508 /*
509 [TestAttribute, Ignore]
510 public void ElementAtTestCase()
511 {
512 ParallelTestHelper.Repeat (() => {
513 Assert.AreEqual(1, baseEnumerable.ElementAt(0), "#1");
514 Assert.AreEqual(51, baseEnumerable.ElementAt(50), "#2");
515 Assert.AreEqual(489, baseEnumerable.ElementAt(488), "#3");
516 });
517 }
518
519 [TestAttribute, Ignore]
520 public void TakeTestCase()
521 {
522 ParallelTestHelper.Repeat (() => {
523 ParallelQuery<int> async = baseEnumerable.AsParallel().Take(2000);
524 IEnumerable<int> sync = baseEnumerable.Take(2000);
525
526 AreEquivalent(sync, async, 1);
527
528 async = baseEnumerable.AsParallel().Take(100);
529 sync = baseEnumerable.Take(100);
530
531 AreEquivalent(sync, async, 2);
532 });
533 }
534
535 [TestAttribute, Ignore]
536 public void SkipTestCase()
537 {
538 ParallelTestHelper.Repeat (() => {
539 ParallelQuery<int> async = baseEnumerable.AsParallel().AsOrdered().Skip(2000);
540 IEnumerable<int> sync = baseEnumerable.Skip(2000);
541
542 AreEquivalent(sync, async, 1);
543
544 async = baseEnumerable.AsParallel().Skip(100);
545 sync = baseEnumerable.Skip(100);
546
547 Assert.AreEqual(sync.Count(), async.Count(), "#2");
548 });
549 }
550
551 [TestAttribute, Ignore]
552 public void ZipTestCase()
553 {
554 ParallelTestHelper.Repeat (() => {
555 ParallelQuery<int> async1 = ParallelEnumerable.Range(0, 10000);
556 ParallelQuery<int> async2 = ParallelEnumerable.Repeat(1, 10000).Zip(async1, (e1, e2) => e1 + e2);
557
558 int[] expected = Enumerable.Range (1, 10000).ToArray ();
559 CollectionAssert.AreEquivalent(expected, Enumerable.ToArray (async2), "#1");
560 });
561 }
562 */
563 [Test]
564 public void RangeTestCase ()
565 {
566 ParallelTestHelper.Repeat (() => {
567 IEnumerable<int> sync = Enumerable.Range(1, 1000);
568 IEnumerable<int> async = ParallelEnumerable.Range(1, 1000);
569
570 AreEquivalent (sync, async, 1);
571 });
572 }
573
574 [Test]
575 public void RepeatTestCase ()
576 {
577 ParallelTestHelper.Repeat (() => {
578 IEnumerable<int> sync = Enumerable.Repeat(1, 1000);
579 IEnumerable<int> async = ParallelEnumerable.Repeat(1, 1000);
580
581 AreEquivalent (sync, async, 1);
582 });
583 }
584
585 [Test]
586 public void TestSum ()
587 {
588 int [] data = {1, 2, 3, 4};
589
590 Assert.AreEqual (10, data.AsParallel().Sum ());
591 }
592
593 [Test]
594 public void SumOnEmpty ()
595 {
596 int [] data = {};
597
598 Assert.AreEqual (0, data.AsParallel().Sum ());
599 }
600
601 [Test]
602 public void TestMax ()
603 {
604 int [] data = {1, 3, 5, 2};
605
606 Assert.AreEqual (5, data.AsParallel().Max ());
607 }
608
609 [Test]
610 public void TestMin ()
611 {
612 int [] data = {3, 5, 2, 6, 1, 7};
613
614 Assert.AreEqual (1, data.AsParallel().Min ());
615 }
616
617 [Test]
618 public void TestToListOrdered ()
619 {
620 int [] data = { 2, 3, 5 };
621
622 var list = data.AsParallel().AsOrdered().ToList ();
623
624 AssertAreSame (data, list);
625 AssertIsOrdered (list, data.Length);
626
627 Assert.AreEqual (typeof (List<int>), list.GetType ());
628 }
629
630 [Test]
631 public void TestToArrayOrdered ()
632 {
633 ICollection<int> coll = new List<int> ();
634 coll.Add (0);
635 coll.Add (1);
636 coll.Add (2);
637
638 int [] result = {0, 1, 2};
639
640 var array = coll.AsParallel().AsOrdered().ToArray ();
641
642 AssertAreSame (result, array);
643 AssertIsOrdered (array, result.Length);
644
645 Assert.AreEqual (typeof (int []), array.GetType ());
646 }
647
648 [Test]
649 public void TestToList ()
650 {
651 int [] data = {3, 5, 2};
652
653 var list = data.AsParallel().ToList ();
654
655 CollectionAssert.AreEquivalent (data, list);
656
657 Assert.AreEqual (typeof (List<int>), list.GetType ());
658 }
659
660 [Test]
661 public void TestToArray ()
662 {
663 ICollection<int> coll = new List<int> ();
664 coll.Add (0);
665 coll.Add (1);
666 coll.Add (2);
667
668 int [] result = {0, 1, 2};
669
670 var array = coll.AsParallel().ToArray ();
671
672 CollectionAssert.AreEquivalent (result, array);
673
674 Assert.AreEqual (typeof (int []), array.GetType ());
675 }
676
677
678 [Test]
679 public void TestAverageOnInt32 ()
680 {
681 Assert.AreEqual (23.25, (new int [] { 24, 7, 28, 34 }).Average ());
682 }
683
684 [Test]
685 public void TestAverageOnInt64 ()
686 {
687 Assert.AreEqual (23.25, (new long [] { 24, 7, 28, 34 }).Average ());
688 }
689
690 /*
691 [Test]
692 public void AnyArgumentNullTest ()
693 {
694 string [] data = { "2", "1", "5", "3", "4" };
695
696
697 // Any<TSource> ()
698 AssertException<ArgumentNullException> (delegate () { ((IEnumerable<string>) null).AsParallel ().Any (); });
699
700 // Any<TSource> (Func<TSource, bool>)
701 AssertException<ArgumentNullException> (delegate () { ((IEnumerable<string>) null).AsParallel ().Any (x => true); });
702 AssertException<ArgumentNullException> (delegate () { data.AsParallel ().Any ((Func<string, bool>) null); });
703 }*/
704
705 [Test]
706 public void AnyTest ()
707 {
708 int [] data = { 5, 2, 3, 1, 6 };
709 int [] empty = { };
710
711
712 // Any<TSource> ()
713 Assert.IsTrue (data.AsParallel ().Any ());
714 Assert.IsFalse (empty.AsParallel ().Any ());
715
716 // Any<TSource> (Func<TSource, bool>)
717 Assert.IsTrue (data.AsParallel ().Any (x => x == 5));
718 Assert.IsFalse (data.AsParallel ().Any (x => x == 9));
719 Assert.IsFalse (empty.AsParallel ().Any (x => true));
720 }
721
722 /*
723 [Test]
724 public void AllArgumentNullTest ()
725 {
726 string [] data = { "2", "1", "5", "3", "4" };
727
728 AssertException<ArgumentNullException> (delegate () { ((IEnumerable<string>) null).AsParallel ().All (x => true); });
729 AssertException<ArgumentNullException> (delegate () { data.AsParallel ().All ((Func<string, bool>) null); });
730 }*/
731
732 [Test]
733 public void AllTest ()
734 {
735 int [] data = { 5, 2, 3, 1, 6 };
736 int [] empty = { };
737
738 Assert.IsTrue (data.AsParallel ().All (x => true));
739 Assert.IsFalse (data.AsParallel ().All (x => x != 1));
740 Assert.IsTrue (empty.AsParallel ().All (x => false));
741 }
742 }
743 }
git-svn mirror of mcs