Merge pull request #1586 from vkargov/master

[mono.git] / mcs / class / System.Core / Test / System.Linq / ParallelEnumerableTests.cs

diff --git a/mcs/class/System.Core/Test/System.Linq/ParallelEnumerableTests.cs b/mcs/class/System.Core/Test/System.Linq/ParallelEnumerableTests.cs
index 6629133fc3d39204bc59de9893b5a9b7bda7bef3..d9fac1818d3704bc36d573df94e71dbab5d698f5 100644 (file)
--- a/mcs/class/System.Core/Test/System.Linq/ParallelEnumerableTests.cs
+++ b/mcs/class/System.Core/Test/System.Linq/ParallelEnumerableTests.cs
@@ -313,7 +313,7 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4, 5};
                        int [] result = {3, 4, 5};
 
-                       AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Skip (3).ToArray ());
+                       AssertAreSame (result, data.AsParallel ().AsOrdered ().Skip (3).ToArray ());
                }
                
                [Test]
@@ -322,7 +322,7 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4, 5};
                        int [] result = {3, 4, 5};
 
-                       AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Skip (3));
+                       AssertAreSame (result, data.AsParallel ().AsOrdered ().Skip (3));
                }
 
                [Test]
@@ -331,7 +331,7 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4, 5};
                        int [] result = {3, 4, 5};
 
-                       AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().SkipWhile (i => i < 3));
+                       AssertAreSame (result, data.AsParallel ().AsOrdered ().SkipWhile (i => i < 3));
                }
 
                [Test]
@@ -340,7 +340,7 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4, 5};
                        int [] result = {0, 1, 2};
 
-                       AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().Take (3));
+                       AssertAreSame (result, data.AsParallel ().AsOrdered ().Take (3));
                }
 
                [Test]
@@ -349,7 +349,7 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4, 5};
                        int [] result = {0, 1, 2};
 
-                       AssertAreSame (result, data.AsReallyParallel ().AsOrdered ().TakeWhile (i => i < 3));
+                       AssertAreSame (result, data.AsParallel ().AsOrdered ().TakeWhile (i => i < 3));
                }
 
                [Test]
@@ -371,7 +371,7 @@ namespace MonoTests.System.Linq
                        IEnumerable<int> expected = initial.SelectMany ((i) => Enumerable.Range (1, i));
 
                        ParallelTestHelper.Repeat (() => {
-                                       var actual = initial.AsReallyParallel ().AsOrdered ().SelectMany ((i) => Enumerable.Range (1, i));
+                                       var actual = initial.AsParallel ().AsOrdered ().SelectMany ((i) => Enumerable.Range (1, i));
                                        AssertAreSame (expected, actual);
                                });
                }
@@ -381,7 +381,7 @@ namespace MonoTests.System.Linq
                {
                        int [] data = {1, 2, 3};
 
-                       Assert.AreEqual (3, data.AsReallyParallel ().AsOrdered ().Last ());
+                       Assert.AreEqual (3, data.AsParallel ().AsOrdered ().Last ());
                }
 
                [Test]
@@ -389,7 +389,7 @@ namespace MonoTests.System.Linq
                {
                        int [] data = {};
 
-                       Assert.AreEqual (default (int), data.AsReallyParallel ().AsOrdered ().LastOrDefault ());
+                       Assert.AreEqual (default (int), data.AsParallel ().AsOrdered ().LastOrDefault ());
                }
 
                [Test]
@@ -397,7 +397,7 @@ namespace MonoTests.System.Linq
                {
                        int [] data = {1, 2, 3};
 
-                       Assert.AreEqual (1, data.AsReallyParallel ().AsOrdered ().First ());
+                       Assert.AreEqual (1, data.AsParallel ().AsOrdered ().First ());
                }
 
                [Test]
@@ -405,7 +405,7 @@ namespace MonoTests.System.Linq
                {
                        int [] data = {};
 
-                       Assert.AreEqual (default (int), data.AsReallyParallel ().AsOrdered ().FirstOrDefault ());
+                       Assert.AreEqual (default (int), data.AsParallel ().AsOrdered ().FirstOrDefault ());
                }
                
                [Test]
@@ -414,8 +414,8 @@ namespace MonoTests.System.Linq
                        int [] data = {0, 1, 2, 3, 4};
                        int [] result = {4, 3, 2, 1, 0};
 
-                       AssertAreSame (result, ((IEnumerable<int>)data).Select ((i) => i).AsReallyParallel ().AsOrdered ().Reverse ());
-                       AssertAreSame (result, ParallelEnumerable.Range (0, 5).AsReallyParallel ().AsOrdered ().Reverse ());
+                       AssertAreSame (result, ((IEnumerable<int>)data).Select ((i) => i).AsParallel ().AsOrdered ().Reverse ());
+                       AssertAreSame (result, ParallelEnumerable.Range (0, 5).AsParallel ().AsOrdered ().Reverse ());
                }
                
                [Test]
@@ -561,9 +561,9 @@ namespace MonoTests.System.Linq
                public void ElementAtTestCase()
                {
                        //ParallelTestHelper.Repeat (() => {
-                                       Assert.AreEqual(1, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(0), "#1");
-                                       Assert.AreEqual(51, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(50), "#2");
-                                       Assert.AreEqual(489, baseEnumerable.AsReallyParallel ().AsOrdered ().ElementAt(488), "#3");
+                                       Assert.AreEqual(1, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(0), "#1");
+                                       Assert.AreEqual(51, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(50), "#2");
+                                       Assert.AreEqual(489, baseEnumerable.AsParallel ().AsOrdered ().ElementAt(488), "#3");
                        //});
                }
 
@@ -591,12 +591,11 @@ namespace MonoTests.System.Linq
                {
                        var items = new [] { 1, 2, 3 };
                        var items2 = new [] { 1, 2, 3, 4 };
-                       var actual = items.AsReallyParallel ().Join (items2.AsReallyParallel (), i => i, i => i, (e1, e2) => e1 + e2);
+                       var actual = items.AsReallyParallel ().Join (items2.AsParallel (), i => i, i => i, (e1, e2) => e1 + e2);
                        AreEquivalent (new[] { 2, 4, 6 }, actual);
                }
 
                [Test]
-               [Category ("NotWorking")] // Deadlocks randomly
                public void TestGroupBy ()
                {
                        int num = 100;
@@ -624,12 +623,12 @@ namespace MonoTests.System.Linq
                public void TakeTestCase()
                {
                        ParallelTestHelper.Repeat (() => {
-                               ParallelQuery<int> async_res = baseEnumerable.AsReallyParallel ().AsOrdered ().Take(800);
+                               ParallelQuery<int> async_res = baseEnumerable.AsParallel ().AsOrdered ().Take(800);
                                IEnumerable<int> sync = baseEnumerable.Take(800);
 
                                AreEquivalent(sync, async_res);
 
-                               async_res = baseEnumerable.AsReallyParallel ().AsOrdered ().Take(100);
+                               async_res = baseEnumerable.AsParallel ().AsOrdered ().Take(100);
                                sync = baseEnumerable.Take(100);
 
                                AreEquivalent(sync, async_res);
@@ -656,7 +655,7 @@ namespace MonoTests.System.Linq
                public void SkipTestCase()
                {
                        ParallelTestHelper.Repeat (() => {
-                               ParallelQuery<int> async_res = baseEnumerable.AsReallyParallel ().AsOrdered().Skip (800);
+                               ParallelQuery<int> async_res = baseEnumerable.AsParallel ().AsOrdered().Skip (800);
                                IEnumerable<int> sync = baseEnumerable.Skip (800);
                                
                                AreEquivalent (sync, async_res);
@@ -778,14 +777,14 @@ namespace MonoTests.System.Linq
 
                        int [] result = {0, 1, 2};
 
-                       var array = coll.AsReallyParallel ().AsOrdered().ToArray ();
+                       var array = coll.AsParallel ().AsOrdered().ToArray ();
 
                        AssertAreSame (result, array);
                        AssertIsOrdered (array, result.Length);
 
                        Assert.AreEqual (typeof (int []), array.GetType ());
 
-                       array = Enumerable.Range (1, 100).Select ((i) => i).AsReallyParallel ().AsOrdered().ToArray ();
+                       array = Enumerable.Range (1, 100).Select ((i) => i).AsParallel ().AsOrdered().ToArray ();
                        result = Enumerable.Range (1, 100).ToArray ();
 
                        AssertAreSame (result, array);
@@ -897,12 +896,12 @@ namespace MonoTests.System.Linq
                        var data2 = new int[] { 1, 2, 4 };
                        var data3 = new int[] { 1, 2, 3, 4 };
 
-                       Assert.IsTrue (data1.AsReallyParallel ().SequenceEqual (data1.AsReallyParallel ()));
-                       Assert.IsTrue (data2.AsReallyParallel ().SequenceEqual (data2.AsReallyParallel ()));
-                       Assert.IsTrue (data3.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
-                       Assert.IsFalse (data1.AsReallyParallel ().SequenceEqual (data2.AsReallyParallel ()));
-                       Assert.IsFalse (data1.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
-                       Assert.IsFalse (data2.AsReallyParallel ().SequenceEqual (data3.AsReallyParallel ()));
+                       Assert.IsTrue (data1.AsParallel ().SequenceEqual (data1.AsParallel ()));
+                       Assert.IsTrue (data2.AsParallel ().SequenceEqual (data2.AsParallel ()));
+                       Assert.IsTrue (data3.AsParallel ().SequenceEqual (data3.AsParallel ()));
+                       Assert.IsFalse (data1.AsParallel ().SequenceEqual (data2.AsParallel ()));
+                       Assert.IsFalse (data1.AsParallel ().SequenceEqual (data3.AsParallel ()));
+                       Assert.IsFalse (data2.AsParallel ().SequenceEqual (data3.AsParallel ()));
                }
 
                [Test]